# Texas Tow & VSF Insurance Leads — TDLR Renewal Dates (`deadwood_data_solutions/texas-tow-vsf-insurance-leads`) Actor

Every Texas tow company and vehicle storage facility with its CURRENT insurance on file at TDLR — carrier, policy type, effective/cancellation dates, fleet size, phone, and site address. Flags pending-cancellation and lapsed-coverage leads. ~5.7k certificates, refreshed daily. Free CRM sync.

- **URL**: https://apify.com/deadwood\_data\_solutions/texas-tow-vsf-insurance-leads.md
- **Developed by:** [K O](https://apify.com/deadwood_data_solutions) (community)
- **Categories:** Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 insurance lead returneds

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Texas Tow & Vehicle Storage Insurance Leads

Every Texas **tow company** and **vehicle storage facility** licensed by the
Texas Department of Licensing and Regulation (TDLR) — delivered as a clean B2B
lead list that includes each business's **current insurance policy on file**.

These are the two TDLR programs required by statute to keep proof of insurance on
file, so the public license extracts carry something no generic business list
has: the holder's **insurance carrier, policy type, effective date, cancellation
date, and (for tow companies) insured vehicle count** — alongside the business
phone and physical site address.

If you sell **commercial auto, garage liability, or on-hook / garagekeepers
insurance**, this is a targeted book of ~5,700 Texas businesses that are legally
required to carry coverage, with the incumbent carrier and renewal timing
already attached.

### Pain points

- TDLR publishes the raw license extracts, but they're two separate CSVs
  (`TowCompanies.csv`, `VSFs.csv`) with policy-type and status left as internal
  codes — there's no single "who's insured, who just lapsed, who's about to"
  view.
- Generic Texas business lists don't tell you which businesses are *legally
  required* to carry commercial auto or garage liability coverage, let alone
  who their current carrier is or when that policy runs out.
- Finding lapsed or soon-to-cancel policies today means downloading both CSVs
  yourself and computing cancellation math by hand, on every refresh.

### What we solve

- **Current carrier on every record (100% fill).** See exactly who insures each
  tow company and storage lot today — target a competitor's book or find your
  own expiring policies.
- **Pending-cancellation and lapsed flags, computed for you.** `insuranceStatus`
  separates **`lapsed`** (coverage already ended — the business is uninsured
  now and legally cannot operate) from **`cancelling`** (a cancellation is
  filed for a future date — coverage is about to end). These are the
  highest-intent replacement-insurance leads.
- **Policy effective date on every record.** Filter to freshly insured or
  renewed businesses with `effectiveWithinDays` — a natural shopping window.
- **Tow fleet size.** `vehicleCount` (insured vehicles reported by the tow
  company) is a direct proxy for commercial-auto premium.
- **97% business phone, 100% physical site address.**
- **Free discovery before you spend anything.** Turn on `listLocationsOnly` to
  get the exact spelling of every city and county actually present in the
  current TDLR extract, free — nothing is charged and a typo in
  `cities`/`counties` can't silently return zero results on a billed run.

### Source & freshness

Data comes from TDLR's public license extracts, `TowCompanies.csv` and
`VSFs.csv`, published at `tdlr.texas.gov`. TDLR **refreshes these files daily**,
so a scheduled run keeps your pipeline current. No API key, login, or captcha.

Set `onlyNewSinceLastRun` (default on) for scheduled runs: the Actor remembers
what it has seen, keyed on certificate number + policy effective date +
cancellation date, so a recurring schedule surfaces only genuinely new
certificates, policy renewals/changes and newly filed cancellations — you are
not re-charged for the unchanged book.

### Example input

```json
{
  "facilityTypes": ["towCompany"],
  "onlyLapsed": true,
  "cities": ["HOUSTON", "DALLAS"],
  "minVehicleCount": 3
}
```

Tow companies in Houston or Dallas that currently have lapsed insurance and run
a fleet of 3+ vehicles. Leave every filter empty for the full ~5,700-record book.

#### Input options

| Field | What it does |
|-------|--------------|
| `facilityTypes` | `towCompany`, `vehicleStorage`, or empty for both. |
| `onlyLapsed` | Only holders whose coverage has already lapsed (uninsured now). |
| `effectiveWithinDays` | Only policies effective in the last N days (newly insured/renewed). |
| `carriers` | Only holders whose current carrier name contains one of these (substring). |
| `minVehicleCount` | Only tow companies with at least this many insured vehicles. |
| `cities` / `counties` / `zipPrefixes` | Filter by physical site location. |
| `maxItems` | Cap the number of records. |
| `onlyNewSinceLastRun` | Skip records already returned in a prior run (recommended for schedules). |
| `listLocationsOnly` | Discovery mode — returns the cities/counties present in the current extract and stops. Free, nothing charged. |

### Output fields

| Field | Description |
|-------|-------------|
| `leadId` | Stable id: certificate + policy effective + cancellation date. |
| `certificateNumber`, `certificateType` | TDLR certificate identifiers. |
| `facilityType`, `facilityLabel` | `towCompany` / `vehicleStorage`. |
| `businessName`, `dbaName` | Legal name and assumed (DBA) name. |
| `phone`, `phoneDigits` | Business phone, formatted and digits-only. |
| `siteStreet`, `siteCity`, `siteCounty`, `siteState`, `siteZip` | Physical site (the yard / impound lot). |
| `mailStreet`, `mailCity`, `mailState`, `mailZip` | Mailing / billing address. |
| `insuranceCarrier` | Current insurance company on file. |
| `tdiNumber` | Carrier's Texas Department of Insurance company number. |
| `policyTypeCode` | TDLR's internal policy-type code (surfaced raw — see note below). |
| `coverageAmount` | Coverage amount, when TDLR publishes one (often blank). |
| `policyEffectiveDate`, `policyCancelDate` | Policy effective and cancellation dates (ISO). |
| `policyAgeDays` | Days since the policy took effect. |
| `insuranceStatus` | `active`, `cancelling` (future cancel date) or `lapsed` (past cancel date). |
| `isInsuranceLapsed`, `hasCancellationOnFile` | Convenience booleans. |
| `vehicleCount`, `isMultiTruckFleet` | Insured vehicle count (tow companies only). |
| `source` | Full source attribution. |

**A note on honesty:** every field is taken verbatim from TDLR's public
extracts. `policyTypeCode` is TDLR's own internal code and is surfaced raw rather
than guessed at, `coverageAmount` is passed through only when TDLR populates it,
and no phone numbers or emails are appended from third-party sources — what you
get is the public record.

One real record, pulled from an actual run — not a placeholder:

```json
{
  "leadId": "006599388C|2026-05-14|",
  "certificateNumber": "006599388C",
  "certificateType": "Tow Company",
  "facilityType": "towCompany",
  "facilityLabel": "Tow Company",
  "businessName": "AMERICAN TOWING AND AUTO REPAIR OF DALL",
  "dbaName": null,
  "phone": "(972) 322-1596",
  "phoneDigits": "9723221596",
  "siteStreet": "625 E VISTA RIDGE MALL DR 513",
  "siteCity": "LEWISVILLE",
  "siteCounty": "DENTON",
  "siteState": "TX",
  "siteZip": "75067-3708",
  "mailStreet": "1301 JUSTIN RD SUITE 201 PMB 1070",
  "mailCity": "LEWISVILLE",
  "mailState": "TX",
  "mailZip": "75077-2183",
  "insuranceCarrier": "PROGRESSIVE COUNTY MUTUAL INSURANCE COMPANY",
  "tdiNumber": "67940",
  "policyTypeCode": "10",
  "coverageAmount": null,
  "policyEffectiveDate": "2026-05-14",
  "policyCancelDate": null,
  "policyAgeDays": 84,
  "insuranceStatus": "active",
  "isInsuranceLapsed": false,
  "hasCancellationOnFile": false,
  "vehicleCount": 2,
  "isMultiTruckFleet": true,
  "source": "Texas Department of Licensing and Regulation (TDLR) — Tow Company / Vehicle Storage Facility license extracts (tdlr.texas.gov/dbproduction2)"
}
```

### Pricing (Pay-Per-Event)

- **`query`** — charged once per run for the TDLR extract sweep.
- **`insurance-lead`** — charged per normalized lead pushed. This is the primary event.
- `apify-actor-start` (Apify-managed) — covers baseline compute per run.
- `listLocationsOnly` discovery runs and syncing records to a connected app (below) are both free and never billable.

### Sync to your CRM, Notion, HubSpot, Airtable or Supabase (optional)

Turn on `syncEnabled` to also send each new lead straight to a connected
app — free, with no extra charge. Connect the app under **Integrations** in
Apify Console, pick it as `syncDestination`, and set `syncWriteTool` to the
name of the tool that creates one record there (run the
[dataset-sync-connector](https://apify.com/deadwood_data_solutions/dataset-sync-connector)
Actor in `list-tools` mode against the same connector if you don't know the
name). A sync failure is logged as a warning and never blocks the dataset —
your leads always land here first regardless of what the destination does. No
event is charged for records sent to a destination.

### FAQ

**How am I charged?**

One `query` event per run, plus one `insurance-lead` event per normalized record pushed. A business matching several of your filters (e.g. a city and a carrier substring) still appears once per run and is charged once — filtering narrows the list, it doesn't multiply the bill. `listLocationsOnly` runs are entirely free.

**Where does the data come from?**

TDLR's public license extracts, `TowCompanies.csv` and `VSFs.csv` (`tdlr.texas.gov`) — the same files TDLR itself publishes for tow companies and vehicle storage facilities, the two license types Texas statute requires to keep proof of insurance on file.

**How fresh is it?**

TDLR refreshes both source extracts daily. Schedule the actor with `onlyNewSinceLastRun` on and each run surfaces only genuinely new certificates, policy renewals/changes, and newly filed cancellations.

### Disclaimer

This Actor returns Texas public-record licensing data published by TDLR. Use it
in compliance with applicable laws and regulations (including
telemarketing/solicitation rules). It is provided for lawful B2B sales and
marketing use.

# Actor input Schema

## `facilityTypes` (type: `array`):

Which TDLR programs to pull. Values: towCompany (licensed tow companies, ~3.8k) and vehicleStorage (vehicle storage / impound facilities, ~1.9k). Leave empty for both.

## `onlyLapsed` (type: `boolean`):

Return only certificate holders whose on-file policy has a cancellation date on or before today — i.e. currently uninsured. A Texas tow company or storage lot legally cannot operate without the required coverage, so these are the highest-intent replacement-insurance leads.

## `effectiveWithinDays` (type: `integer`):

Only holders whose current policy took effect within the last N days — newly insured or freshly renewed businesses (a shopping / switch window). Leave blank for all. About a third of the book has a policy effective in the current year.

## `carriers` (type: `array`):

Only holders whose current carrier name contains one of these (case-insensitive substring), e.g. PROGRESSIVE, NATIONAL LIABILITY. Use to target (or exclude by omission) a competitor's book of business. 120+ distinct carriers appear.

## `minVehicleCount` (type: `integer`):

Only tow companies reporting at least this many insured vehicles — a proxy for fleet size and commercial-auto premium. Vehicle storage facilities do not report a vehicle count and are excluded when this is set above 0.

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

Only facilities whose physical site city matches (case-insensitive exact match, e.g. HOUSTON, DALLAS, SAN ANTONIO).

## `counties` (type: `array`):

Only facilities whose physical site county matches (case-insensitive exact match, e.g. HARRIS, DALLAS, TARRANT).

## `zipPrefixes` (type: `array`):

Only facilities whose site ZIP starts with one of these prefixes (e.g. 77 for greater Houston, 75 for Dallas, 787 for Austin).

## `listLocationsOnly` (type: `boolean`):

Return the cities and counties actually present in the current TDLR extract — the exact values you can pass to 'Site cities' / 'Site counties' — then stop. No records normalized and nothing charged. Use this first to get spelling exactly right before spending on a real run.

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

Stop after this many normalized leads have been pushed. Leave blank for no limit.

## `onlyNewSinceLastRun` (type: `boolean`):

Recommended for scheduled runs. Uses persisted state keyed on certificate + policy effective + cancellation date, so a recurring schedule only charges for genuinely new certificates, policy renewals/changes and newly filed cancellations — not the unchanged book.

## `syncEnabled` (type: `boolean`):

Send each new record to a connected destination (Notion, HubSpot, Airtable, Supabase, or any Apify MCP connector) in addition to the dataset. Free — this never triggers a billable event. A sync failure never blocks or fails the run.

## `syncDestination` (type: `string`):

Connect the app under Integrations in Apify Console first, then pick it here. Required only if 'Sync new records' is on.

## `syncWriteTool` (type: `string`):

Name of the destination's MCP tool that creates one record, e.g. 'create\_page' for Notion, 'insert' for Supabase. Run the dataset-sync-connector Actor in 'list-tools' mode against the same destination if you don't know it.

## `syncFieldMap` (type: `object`):

Maps destination argument names to this Actor's output field names, e.g. {"title": "legalName", "phone": "phone"}. Leave empty to pass each record through unchanged.

## `syncExtraArgs` (type: `object`):

Fixed arguments merged into every sync write call, e.g. {"database\_id": "abc123"} for Notion.

## Actor input object example

```json
{
  "facilityTypes": [],
  "onlyLapsed": false,
  "carriers": [],
  "cities": [],
  "counties": [],
  "zipPrefixes": [],
  "listLocationsOnly": false,
  "maxItems": 250,
  "onlyNewSinceLastRun": true,
  "syncEnabled": false,
  "syncFieldMap": {},
  "syncExtraArgs": {}
}
```

# Actor output Schema

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

All normalized records from this run as JSON.

## `resultsCsv` (type: `string`):

All normalized records from this run as CSV.

# 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 = {
    "facilityTypes": [],
    "carriers": [],
    "cities": [],
    "counties": [],
    "zipPrefixes": [],
    "maxItems": 250,
    "syncFieldMap": {},
    "syncExtraArgs": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("deadwood_data_solutions/texas-tow-vsf-insurance-leads").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 = {
    "facilityTypes": [],
    "carriers": [],
    "cities": [],
    "counties": [],
    "zipPrefixes": [],
    "maxItems": 250,
    "syncFieldMap": {},
    "syncExtraArgs": {},
}

# Run the Actor and wait for it to finish
run = client.actor("deadwood_data_solutions/texas-tow-vsf-insurance-leads").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 '{
  "facilityTypes": [],
  "carriers": [],
  "cities": [],
  "counties": [],
  "zipPrefixes": [],
  "maxItems": 250,
  "syncFieldMap": {},
  "syncExtraArgs": {}
}' |
apify call deadwood_data_solutions/texas-tow-vsf-insurance-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deadwood_data_solutions/texas-tow-vsf-insurance-leads"
        }
    }
}

```

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/3y7kgSQgYlEGc5qGL/builds/YoFzhM8S1FoQCdNfR/openapi.json