# Dallas TX Building Permit Records & Contractor Lookup (`nimbryxo-studio/dallas-tx-building-permit-records-and-contractor`) Actor

Search City of Dallas building permit filings by type, land use, ZIP code, contractor, date range, or declared value and area, or look up exact permits by permit number.

- **URL**: https://apify.com/nimbryxo-studio/dallas-tx-building-permit-records-and-contractor.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Dallas TX Building Permit Records & Contractor Lookup

Dallas publishes two different building-permit archives: a live permit feed that is updated daily, and a large historical GIS extract that reaches back to 1971. This actor reads both, so you can work with current contractor leads and decades of permit history in one place.

### Two complementary permit sources

| Source | Coverage | Best for |
|---|---|---|
| City of Dallas Open Data (live) | Permits issued from January 2018 to today; updated daily | Contractor names and phone numbers, current filings, ZIP-level lead lists |
| City of Dallas GIS archive | Permits created 1971-02-01 through 2024-11-12 | Long-run research, permit status, council districts, units, zoning, map coordinates |

Live records and historical records share the same core fields. Historical records add status, activity, category, council district, units, land-use code, zoning, and latitude/longitude. Live records add contractor details and Mapsco grid references. Permit-number lookups check both sources and merge the two records when the same permit exists in each.

### What this actor does

- Searches live permits by permit type, land use, ZIP code, contractor text, Mapsco grid, work-description text, street-address text, issue-date range, declared value, and area.
- Searches historical permits by coarse permit type, activity, status, category, council district, ZIP code, land-use text, work-description text, street-address text, issue-date range, value, and area.
- Sorts live results by value, area, or issue date, and historical results by issue date, application date, value, area, or units.
- Looks up exact permit numbers across both sources and merges their fields, so a historical permit can gain status and coordinates while a live permit keeps its contractor information.
- Offers complete dropdowns for every finite value published by each source, plus contains-match overrides where a field has too many values for a practical dropdown.
- Omits any field the original filing never recorded instead of emitting a placeholder.
- Requires no login, cookie, API key, or proxy setup.

### Output per permit

| Field | Availability | Description |
|---|---|---|
| `permitNumber` | Both | Dallas permit number |
| `permitType` | Both | Permit type as published by the source |
| `activity` | Historical | Work activity, e.g. `(A) New Construction` or `(B) Alteration` |
| `status` | Historical | Status when the City extracted the GIS layer in November 2024 |
| `issuedDate` | Both | Issue date in `YYYY-MM-DD` format |
| `createdDate` | Historical | Application/creation date in `YYYY-MM-DD` format |
| `workDescription` | Both | Free-text description of the permitted work |
| `landUse` | Both | Land-use classification |
| `streetAddress` | Both | Address the permit was filed for |
| `zipCode` | Both | Dallas-area ZIP code |
| `value` | Both | Declared project value in USD, when recorded |
| `area` | Both | Declared project area in square feet, when recorded |
| `units` | Historical | Number of dwelling units, when recorded |
| `contractor` | Live | Contractor name, address, and phone exactly as filed |
| `contractorPhone` | Live | Phone number extracted from the contractor text |
| `mapsco` | Live | Dallas Mapsco grid reference |
| `permitCategory` | Historical | `Single Family`, `Multi Family`, or `Commercial` |
| `councilDistrict` | Historical | Dallas City Council district (1-14) |
| `landUseCode` | Historical | City land-use code |
| `zoning` | Historical | Zoning classification from the GIS layer |
| `latitude` | Historical | Permit point latitude (WGS84) |
| `longitude` | Historical | Permit point longitude (WGS84) |
| `sourceUrl` | Both | Link to the record in the source API |
| `dataSource` | Both | Which source (or merged pair) produced the record |
| `recordType` | Both | Always `buildingPermit` |
| `scrapedAt` | Both | UTC timestamp of the scrape |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` for live permits, `historicalPermits` for the 1971-2024 archive, or `byPermitNumbers` for exact lookups across both. |
| `permitType` | string | `— (any)` | One exact live permit type from the complete 167-value list. |
| `permitTypeCustom` | string | `—` | Contains-match on the live permit type; takes precedence over `permitType`. |
| `landUse` | string | `— (any)` | One exact live land use from the complete 194-value list. |
| `landUseCustom` | string | `—` | Contains-match on the live land use; takes precedence over `landUse`. |
| `zipCode` | string | `— (any)` | One Dallas-area ZIP code; applies to live and historical modes. |
| `workDescriptionKeyword` | string | `—` | Keep permits whose work description contains this text. |
| `streetAddressKeyword` | string | `—` | Keep permits whose street address contains this text. |
| `contractorKeyword` | string | `—` | Keep live permits whose contractor text contains this text. |
| `mapscoKeyword` | string | `—` | Keep live permits whose Mapsco grid contains this text. |
| `hasContractor` | boolean | `false` | Keep only live permits that name a contractor. |
| `issuedDateFrom` | string | `—` | Earliest issue date to include, `YYYY-MM-DD`. |
| `issuedDateTo` | string | `—` | Latest issue date to include, `YYYY-MM-DD`. |
| `minValue` | integer | `—` | Lowest declared permit value (USD) to include. |
| `maxValue` | integer | `—` | Highest declared permit value (USD) to include. |
| `minArea` | integer | `—` | Smallest declared area (sq ft) to include. |
| `maxArea` | integer | `—` | Largest declared area (sq ft) to include. |
| `sortBy` | string | `default` | Live-mode ordering: `default`, `valueHighToLow`, `valueLowToHigh`, `areaHighToLow`, `areaLowToHigh`, `issuedDateNewestFirst`, or `issuedDateOldestFirst`. |
| `historicalPermitType` | string | `— (any)` | One coarse historical permit type, e.g. `Building (BU)`. |
| `historicalActivity` | string | `— (any)` | One historical activity value. |
| `historicalStatus` | string | `— (any)` | One historical permit status. |
| `historicalCategory` | string | `— (any)` | `Single Family`, `Multi Family`, or `Commercial`. |
| `councilDistrict` | string | `— (any)` | One Dallas council district, 1-14. |
| `historicalLandUseKeyword` | string | `—` | Contains-match on the historical land-use description. |
| `historicalSortBy` | string | `issuedDateNewestFirst` | Historical ordering: issue date, application date, value, area, or units, in either direction. |
| `permitNumbers` | array | `[]` | Exact permit numbers to fetch. Live records are checked first; historical records fill missing numbers and merge extra fields. |
| `maxItems` | integer | `50` | Maximum number of records to return per run; up to 10,000. To collect more, split by smaller date ranges, permit types, or council districts and combine the datasets. |

#### Example: live new single-family construction

```json
{
  "mode": "search",
  "permitType": "Building (BU) Single Family  New Construction",
  "maxItems": 50
}
```

#### Example: live contractor leads in one ZIP code

```json
{
  "mode": "search",
  "zipCode": "75201",
  "hasContractor": true,
  "minValue": 500000,
  "sortBy": "valueHighToLow",
  "maxItems": 100
}
```

#### Example: historical issued commercial alterations

```json
{
  "mode": "historicalPermits",
  "historicalPermitType": "Building (BU)",
  "historicalActivity": "(B) Alteration",
  "historicalCategory": "Commercial",
  "historicalStatus": "Issued",
  "councilDistrict": "11",
  "issuedDateFrom": "2024-01-01",
  "issuedDateTo": "2024-11-12",
  "historicalSortBy": "valueHighToLow",
  "maxItems": 100
}
```

#### Example: lookup by permit number across both sources

```json
{
  "mode": "byPermitNumbers",
  "permitNumbers": ["2003133024", "2411126010", "7100163037"]
}
```

### Use cases

- **Contractor lead generation** - find live permits with a named contractor for the trades and neighborhoods you serve.
- **Neighborhood development research** - compare recent filings with historical construction patterns by ZIP, council district, or land use.
- **Property due diligence** - check whether a specific address or permit number appears in either Dallas archive.
- **Market sizing** - total declared permit value, area, or dwelling units across a type, category, or district.
- **Civic and academic research** - study five decades of Dallas permitting, including final status and geographic distribution.

### Data notes

**How current is the live data?**
The City of Dallas Open Data feed is updated daily and currently holds permits issued from January 2018 onward. The record count changes as new permits are added.

**How current is the historical data?**
The GIS archive was extracted from the City's permitting system on 2024-11-12 and is not updated. It covers permits created from 1971-02-01 through that date. The archive also contains unissued applications that never received an issue date: they are returned when your status or permit-type filter selects them, sort after issued permits on issue-date sorts, and are omitted when you filter by an issue-date range.

**Why do some historical records have no `issuedDate`?**
The GIS archive includes applications that were still in review, rejected, withdrawn, or otherwise never issued when the City extracted the layer. These rows carry their real status but no issue date, so the field is omitted instead of being shown as a placeholder.

**Why do some fields appear on only some records?**
The two archives publish different field sets. Contractor names, contractor phones, and Mapsco grids exist only in the live feed. Status, activity, category, council district, units, land-use code, zoning, and coordinates exist only in the historical layer. Fields are omitted when the source has no value.

**Why do some records have no `value` or `area`?**
Many alteration and trade permits never had a declared dollar value or square footage. A recorded zero is treated as "not recorded", so the field is left off rather than shown as a misleading `0`.

**Why does ascending value/area sorting skip zero-valued rows?**
A large share of permits have no recorded value or area. Sorting ascending without a floor would put every not-recorded permit first. The ascending sort therefore starts at 1, while descending sorts naturally leave those records at the bottom.

**What happens when a permit exists in both archives?**
Permit-number lookups use the live record as the primary record and fill any missing fields from the historical record. Shared fields keep the live value; historical-only fields such as `status`, `councilDistrict`, and `latitude` are added.

**Are the coordinates available for live permits?**
No. The live open-data feed publishes only a street address, ZIP code, and Mapsco grid. Coordinates come from the historical GIS layer.

**How many records can one run return?**
One run returns at most `maxItems` records (maximum 10,000). The live feed currently holds about 397,000 permits and the historical archive about 1.8 million, so a broad query can match far more than one run can emit. To collect a larger set, split the query into smaller date ranges, permit types, council districts, or ZIP codes and combine the datasets. Capped runs of 1,000 or more set a status message so a full run is never mistaken for an exhausted source.

**Why do seven ZIP codes return no historical permits?**
The live feed contains seven ZIP codes that have no clean rows in the 1971-2024 GIS archive: 75024, 75039, 75052, 75104, 75141, 75180, and 75270. They are missing from that snapshot (four appear only inside malformed combined ZIP values), so a historical search on one of them returns 0 records by design. The same ZIPs work in live mode.

**Does the historical archive include applications that were never issued?**
Yes. About 154,000 of the 1.8 million historical rows have no issue date because they were cancelled, rejected, still in review, or otherwise not issued when the City extracted the archive. They are returned when a status, activity, or permit-type filter selects them, sort last on issue-date sorts, and are omitted when an issue-date range is set. A small number of rows whose status is `Issued` also lack an issue date in the City's extract; the actor keeps the source status and omits the missing date rather than inventing one.

**Is this affiliated with the City of Dallas?**
No. This actor reads public City of Dallas data and is not affiliated with, endorsed by, or connected to the City of Dallas.

# Actor input Schema

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

Which Dallas permit source and lookup path to use.

## `permitType` (type: `string`):

Filter live permits to one exact type (mode=search). The list covers all 167 types in the current dataset, including the newer Accela-era names. Use 'Any permit type' to skip this filter.

## `permitTypeCustom` (type: `string`):

Free-text contains-match on the live permit type (mode=search). Takes precedence over 'Permit type (live permits)' when set. Example: 'Solar'.

## `landUse` (type: `string`):

Filter live permits to one exact land-use classification (mode=search). The list covers all 194 non-empty values currently in the dataset. Use 'Any land use' to skip this filter.

## `landUseCustom` (type: `string`):

Free-text contains-match on the live land use (mode=search). Takes precedence over 'Land use (live permits)' when set. Example: 'HOSPITAL'.

## `zipCode` (type: `string`):

Restrict results to one Dallas-area ZIP code. Works in both live and historical modes.

## `workDescriptionKeyword` (type: `string`):

Only include permits whose work description contains this text (case-insensitive), e.g. 'swimming pool', 'water heater', 'roof'. Works in both live and historical modes.

## `streetAddressKeyword` (type: `string`):

Only include permits whose street address contains this text (case-insensitive), e.g. 'MAIN ST', 'ELM'. Works in both live and historical modes.

## `contractorKeyword` (type: `string`):

Only include live permits whose contractor field contains this text (case-insensitive), e.g. a contractor company name. Historical GIS records do not publish contractor names.

## `mapscoKeyword` (type: `string`):

Only include live permits whose Dallas Mapsco grid reference contains this text (case-insensitive), e.g. '54-B'. There are 3,000+ distinct values, so this is contains-match only.

## `hasContractor` (type: `boolean`):

Skip live permits whose contractor field is blank or the owner-builder placeholder. Useful for contractor lead lists. Historical records never carry contractor data.

## `issuedDateFrom` (type: `string`):

Only include permits issued on or after this date. Live data covers 2018 to today; historical data covers 1971-02-01 through 2024-11-12.

## `issuedDateTo` (type: `string`):

Only include permits issued on or before this date. Live data covers 2018 to today; historical data covers 1971-02-01 through 2024-11-12.

## `minValue` (type: `integer`):

Drop permits with a declared value lower than this. Works in both live and historical modes.

## `maxValue` (type: `integer`):

Drop permits with a declared value higher than this. Works in both live and historical modes.

## `minArea` (type: `integer`):

Drop permits with a declared area smaller than this. Works in both live and historical modes.

## `maxArea` (type: `integer`):

Drop permits with a declared area larger than this. Works in both live and historical modes.

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

Ordering for mode=search. Historical mode uses 'Historical sort by' instead.

## `historicalPermitType` (type: `string`):

Filter historical permits (mode=historicalPermits) to one of the City's 35 permit types. Historical records use the coarse pre-Accela type code, not the longer live permit-type labels.

## `historicalActivity` (type: `string`):

Filter historical permits by activity, such as new construction, alteration, renovation, addition, reconstruction, or finish out.

## `historicalStatus` (type: `string`):

Filter historical permits by the status recorded when the City extracted the layer in November 2024. Some statuses occur only on unissued applications; those records are returned without an issuedDate.

## `historicalCategory` (type: `string`):

Filter historical permits by the City's project category.

## `councilDistrict` (type: `string`):

Filter historical permits to one Dallas City Council district (1-14).

## `historicalLandUseKeyword` (type: `string`):

Contains-match on the historical land-use description. The layer has 600+ detailed values, so a free-text match is more practical than a dropdown. Example: 'RESTAURANT'.

## `historicalSortBy` (type: `string`):

Ordering for mode=historicalPermits.

## `permitNumbers` (type: `array`):

Exact Dallas permit numbers to look up, e.g. '2003133024', '2411126010', or 'RES-PLM-26-002314'. Live records are checked first; historical GIS records fill any missing permit and merge extra fields when both sources have it.

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

Hard cap on emitted records per run (maximum 10,000). To collect more, split by smaller date ranges, permit types, or council districts and combine the datasets.

## Actor input object example

```json
{
  "mode": "search",
  "permitType": "Building (BU) Single Family  New Construction",
  "landUse": "",
  "zipCode": "",
  "hasContractor": false,
  "sortBy": "default",
  "historicalPermitType": "",
  "historicalActivity": "",
  "historicalStatus": "",
  "historicalCategory": "",
  "councilDistrict": "",
  "historicalSortBy": "issuedDateNewestFirst",
  "permitNumbers": [],
  "maxItems": 50
}
```

# Actor output Schema

## `permits` (type: `string`):

Dataset containing all scraped Dallas building permits.

# 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 = {
    "mode": "search",
    "permitType": "Building (BU) Single Family  New Construction",
    "landUse": "",
    "zipCode": "",
    "hasContractor": false,
    "sortBy": "default",
    "historicalPermitType": "",
    "historicalActivity": "",
    "historicalStatus": "",
    "historicalCategory": "",
    "councilDistrict": "",
    "historicalSortBy": "issuedDateNewestFirst",
    "permitNumbers": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/dallas-tx-building-permit-records-and-contractor").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 = {
    "mode": "search",
    "permitType": "Building (BU) Single Family  New Construction",
    "landUse": "",
    "zipCode": "",
    "hasContractor": False,
    "sortBy": "default",
    "historicalPermitType": "",
    "historicalActivity": "",
    "historicalStatus": "",
    "historicalCategory": "",
    "councilDistrict": "",
    "historicalSortBy": "issuedDateNewestFirst",
    "permitNumbers": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/dallas-tx-building-permit-records-and-contractor").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 '{
  "mode": "search",
  "permitType": "Building (BU) Single Family  New Construction",
  "landUse": "",
  "zipCode": "",
  "hasContractor": false,
  "sortBy": "default",
  "historicalPermitType": "",
  "historicalActivity": "",
  "historicalStatus": "",
  "historicalCategory": "",
  "councilDistrict": "",
  "historicalSortBy": "issuedDateNewestFirst",
  "permitNumbers": [],
  "maxItems": 50
}' |
apify call nimbryxo-studio/dallas-tx-building-permit-records-and-contractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/dallas-tx-building-permit-records-and-contractor"
        }
    }
}
```

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/iYojcCeE353gO4A9g/builds/U8HUaFvRTnMukaIdk/openapi.json
