# Building Permits Feed — Austin, TX (`pairsoftwosocks/building-permits-feed`) Actor

Get clean, structured Austin, TX building-permit data as JSON, CSV, or Excel. Filter by issue date, permit type, and valuation to pull fresh permits — great sales leads for contractors, roofers, solar installers, and real-estate investors. Pay per result, no subscription.

- **URL**: https://apify.com/pairsoftwosocks/building-permits-feed.md
- **Developed by:** [John Karoul](https://apify.com/pairsoftwosocks) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 permit records

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

## Building Permits Feed — Austin & Chicago

Get clean, structured **building-permit data for Austin, TX and Chicago, IL** as JSON, CSV, or Excel — no scraping, no parsing government HTML, no dealing with clunky open-data portals. Pick a city and a date range and get back ready-to-use permit records in one consistent shape: address, permit type, valuation, contractor, owner, status, and more.

Built for **contractors, roofers, solar installers, real-estate investors, and researchers** who want fresh permit activity as sales leads or data — without paying enterprise prices.

### Why use it

- **Clean, consistent output.** Every permit — from any supported city — comes back in the same tidy schema, with the full raw source record attached so you can trust and audit the data.
- **Fresh leads.** Filter by issue date to pull just-issued permits — the signal that a property owner is about to spend money.
- **Fair, usage-based pricing.** Pay only per result you actually get. No subscriptions, no minimums.
- **Straight from the official source.** Data comes directly from each city's official open-data portal, so it's authoritative and current.

### What you get

One record per permit, with these fields:

`permit_id`, `issue_date`, `jurisdiction`, `address`, `latitude`, `longitude`, `permit_type`, `work_description`, `valuation`, `contractor_name`, `contractor_license`, `owner`, `status`, `source_url`, `raw`

#### Example output

```json
{
  "permit_id": "2025-151496 EP",
  "issue_date": "2026-01-31T00:00:00.000",
  "jurisdiction": "austin-tx",
  "address": "9113 BELL MOUNTAIN DR, AUSTIN, TX, 78730",
  "latitude": 30.37875914,
  "longitude": -97.82761222,
  "permit_type": "R- 434 Addition & Alterations",
  "work_description": "Addition of 470 sqft on the first level ...",
  "valuation": null,
  "contractor_name": "River City Electric",
  "status": "Inactive Pending Revision",
  "source_url": "https://abc.austintexas.gov/web/permit/public-search-other?..."
}
```

### Input

| Field | Required | Example | Notes |
|---|---|---|---|
| `jurisdiction` | yes | `austin-tx` | `austin-tx` (Austin, TX) or `chicago-il` (Chicago, IL) — more coming |
| `dateFrom` | yes | `2026-01-01` | Permits issued on or after this date (YYYY-MM-DD) |
| `dateTo` | yes | `2026-01-31` | Permits issued on or before this date (YYYY-MM-DD) |
| `permitType` | no | `residential` | Filter by permit class (case-insensitive match) |
| `minValuation` | no | `50000` | Only permits with declared valuation at or above this (USD) |
| `maxResults` | no | `1000` | Cap on how many records to return |

### How to use it

1. Set your **date range** (and any optional filters).
2. Run the actor.
3. Download the results as **JSON, CSV, or Excel**, or pull them via the Apify API into your own app or spreadsheet.

### Good to know

- **Coverage:** **Austin, TX** and **Chicago, IL**. More cities are planned — follow the actor for updates.
- **Owner data:** Chicago records include the property **owner** and the **contractor**; Austin exposes the contractor but not a property owner. Fields a city doesn't provide come back empty (the unified schema is the same for every city).
- **Valuation:** Not every permit has a declared dollar valuation, so the `valuation` field is sometimes empty. When present, it's the city's declared job/reported cost. The `minValuation` filter only returns permits that *have* a valuation at or above your threshold.
- **Data sources:** City of Austin Open Data ("Issued Construction Permits") and City of Chicago Open Data ("Building Permits") — both official Socrata portals.

***

<details>
<summary>For developers (running from source)</summary>

```bash
python3 -m pytest -v                                     # unit tests (no network)
PYTHONPATH=. python3 tests/integration_austin_live.py    # live smoke test
```

Adding a city: add an adapter in `src/sources/<city>.py` (a `jurisdiction` slug + `fetch(...)`), a `<CITY>_FIELD_MAP` in `src/normalize.py`, register it in `SOURCES` in `src/registry.py`, and add the slug to `SUPPORTED_JURISDICTIONS` in `src/inputs.py` and the `.actor/input_schema.json` enum.

Dependencies are pinned to a verified set (see `requirements.txt`) — the Apify SDK must be v3.x; older pins pull a crawlee/pydantic combination that crashes at import.

</details>

# Actor input Schema

## `jurisdiction` (type: `string`):

City to pull permits from.

## `dateFrom` (type: `string`):

Include permits issued on or after this date.

## `dateTo` (type: `string`):

Include permits issued on or before this date.

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

Case-insensitive substring match on the source permit class.

## `minValuation` (type: `number`):

Only permits with declared valuation at or above this.

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

Safety cap on records returned.

## Actor input object example

```json
{
  "jurisdiction": "austin-tx",
  "maxResults": 1000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pairsoftwosocks/building-permits-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pairsoftwosocks/building-permits-feed").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 '{}' |
apify call pairsoftwosocks/building-permits-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pairsoftwosocks/building-permits-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DQUnjvb8zvTUR865P/builds/WqTaXlKydOUiLaJlA/openapi.json