# Seattle Building Permits Scraper (`parseforge/seattle-permits-scraper`) Actor

Scrape building permits from Seattle Open Data (Socrata). Filter by date, type, address, applicant, contractor. Get permit number, status, costs, units, descriptions. No API key required.

- **URL**: https://apify.com/parseforge/seattle-permits-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.42 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏗️ Seattle Building Permits Scraper

> 🚀 **Export every Seattle DCI building permit in seconds.** Filter by **date, permit type, class, status, ZIP, or keyword**, and pull permit numbers, costs, descriptions, housing units, contractor, lat/lon, and 27 more fields. No API key, no registration.

> 🕒 **Last updated:** 2026-05-13 · **📊 27 fields** per record · **🏗️ All Seattle DCI permits** · **🏙️ City of Seattle** · **🔢 17 permit types**

The **Seattle Building Permits Scraper** exports the live Seattle Department of Construction and Inspections permit catalog directly from the City of Seattle Open Data portal (Socrata SODA API). Every record returns **27 normalized fields**, including permit number, permit class (residential, commercial, industrial, institutional, multifamily), permit type description, current status, applied/issued/expires/completed dates, estimated project cost, housing units added or removed, original address, latitude and longitude, contractor company, applicant name, related Master Use Permit ID, days out of corrections, review cycle count, and a direct link to the official DCI portal record.

The catalog covers **every permit DCI has ever issued**, going back decades, refreshed multiple times per day on data.seattle.gov. This Actor lets you slice that dataset by **17 permit types** (New Construction, Addition/Alteration, Demolition, Tenant Improvement, Curb Cut, Relocation, Shoreline Exemption, and more), **24 status values**, **7 property-use classes**, ZIP code, applied-date range, and full-text keyword search.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Real-estate developers, contractors, architects, market analysts, journalists, GIS engineers, civic researchers, prop-tech startups | Lead generation, comparable-project benchmarking, permit pipeline tracking, contractor competitive intelligence, housing-supply analysis, FOIA-style civic research |

---

### 📋 What the Seattle Permits Scraper does

Seven filtering workflows in a single run:

- 🏗️ **Permit type filter.** 17 DCI permit-type descriptions, from New Construction to Curb Cut.
- 🏘️ **Permit class filter.** Commercial, Industrial, Institutional, Multifamily, Single Family/Duplex, Vacant Land, or N/A.
- 📋 **Status filter.** 24 current-status values (Issued, Completed, Under Review, Canceled, Expired, and more).
- 📅 **Applied date range.** Inclusive `appliedFrom` and `appliedTo` in `YYYY-MM-DD` format.
- 📮 **ZIP filter.** Restrict to one Seattle ZIP code (e.g. `98101`, `98115`).
- 🔍 **Keyword full-text search.** Match permit number, description, or address.

Each record includes permit number, official DCI portal URL, permit class and mapping, type description and mapping, status, project description, key dates (applied, issued, expires, completed), estimated cost, housing unit deltas, address, ZIP, lat/lon, contractor company, applicant, related MUP, days out of corrections, and number of review cycles.

> 💡 **Why it matters:** Seattle DCI's portal is searchable but designed for case-by-case lookups, not bulk export. This Actor turns the city's open-data feed into a clean, filtered CSV or JSON of every permit that matches your filters, so analysts and contractors can build dashboards and pipelines without wrestling with Socrata SoQL.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded permits dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>permitType</code></td><td>enum</td><td><code>""</code></td><td>One of 17 permit-type descriptions. Empty = all.</td></tr>
<tr><td><code>permitClass</code></td><td>enum</td><td><code>""</code></td><td>One of 7 use classes (Commercial, Industrial, Institutional, Multifamily, Single Family/Duplex, Vacant Land, N/A).</td></tr>
<tr><td><code>status</code></td><td>enum</td><td><code>""</code></td><td>One of 24 current-status values.</td></tr>
<tr><td><code>appliedFrom</code> / <code>appliedTo</code></td><td>string (YYYY-MM-DD)</td><td><code>null</code></td><td>Inclusive lower / upper bound for applied date.</td></tr>
<tr><td><code>zip</code></td><td>string</td><td><code>""</code></td><td>Seattle ZIP code (e.g. <code>98101</code>).</td></tr>
<tr><td><code>keyword</code></td><td>string</td><td><code>""</code></td><td>Full-text search across permit number, description, address.</td></tr>
</tbody>
</table>

**Example: every new commercial construction permit applied in Q1 2026.**

```json
{
    "maxItems": 500,
    "permitType": "New",
    "permitClass": "Commercial",
    "appliedFrom": "2026-01-01",
    "appliedTo": "2026-03-31"
}
````

**Example: all Issued multifamily permits in 98115.**

```json
{
    "maxItems": 200,
    "permitClass": "Multifamily",
    "status": "Issued",
    "zip": "98115"
}
```

> ⚠️ **Good to Know:** estimated project cost reflects what the applicant declared at the time of filing and is not necessarily the final spend. Housing-unit deltas are city-defined and apply to the parcel as a whole, not always to the single building described.

***

### 📊 Output

Each permit record contains **27 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `permitNumber` | string | `"7133441-CN"` |
| 🔗 `url` | string | `"https://services.seattle.gov/portal/customize/LinkToRecord.aspx?altId=7133441-CN"` |
| 🏘️ `permitClass` | string | null | `"Single Family/Duplex"` |
| 🗂️ `permitClassMapped` | string | null | `"Residential"` |
| 🏗️ `permitTypeDesc` | string | null | `"New"` |
| 🧭 `permitTypeMapped` | string | null | `"Building"` |
| 📋 `statusCurrent` | string | null | `"Scheduled"` |
| 📝 `description` | string | null | `"Construct new SFR/DADU..."` |
| 📅 `appliedDate` | ISO 8601 | null | `"2026-05-08T00:00:00.000"` |
| 📅 `issuedDate` | ISO 8601 | null | `null` |
| 📅 `expiresDate` | ISO 8601 | null | `null` |
| 📅 `completedDate` | ISO 8601 (optional) | `"2026-04-22T..."` |
| 💵 `estimatedProjectCost` | number | null | `200000` |
| 🏠 `housingUnits` | number | null | `0` |
| 🏚️ `housingUnitsRemoved` | number | null | `1` |
| 🏘️ `housingUnitsAdded` | number | null | `1` |
| 🏷️ `housingCategory` | string | null | `"N/A"` |
| 📍 `originalAddress` | string | null | `"7802 ROOSEVELT WAY NE"` |
| 🏙️ `originalCity` | string | null | `"SEATTLE"` |
| 🌎 `originalState` | string | null | `"WA"` |
| 📮 `originalZip` | string | null | `"98115"` |
| 📍 `latitude` / `longitude` | number | null | `47.685 / -122.317` |
| 🛠️ `contractorCompanyName` | string | null | `"ABC Builders LLC"` |
| 👤 `applicantName` | string (optional) | `"Jane Doe"` |
| 🔗 `relatedMup` | string | null | `"3036123-LU"` |
| 🔁 `daysOutCorrections` | number | null | `0` |
| 🔍 `numberReviewCycles` | number | null | `0` |
| 🏗️ `dependentBuilding` | number | null | `0` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T10:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏚️ Single-family demolition, 1225 NE 96TH ST</strong></summary>

```json
{
    "permitNumber": "7133418-DM",
    "url": "https://services.seattle.gov/portal/customize/LinkToRecord.aspx?altId=7133418-DM",
    "permitClass": "Single Family/Duplex",
    "permitClassMapped": "Residential",
    "permitTypeDesc": "Demolition",
    "permitTypeMapped": "Demolition",
    "statusCurrent": "Additional Info Requested",
    "description": "To obtain a permit for demolition for the existing house",
    "estimatedProjectCost": 15000,
    "housingUnits": 0,
    "housingUnitsRemoved": 1,
    "housingUnitsAdded": 1,
    "housingCategory": "N/A",
    "originalAddress": "1225 NE 96TH ST",
    "originalCity": "SEATTLE",
    "originalState": "WA",
    "originalZip": "98115",
    "latitude": 47.69836678,
    "longitude": -122.31363556,
    "scrapedAt": "2026-05-13T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏗️ New SFR/DADU construction, 7802 Roosevelt Way NE</strong></summary>

```json
{
    "permitNumber": "7133441-CN",
    "url": "https://services.seattle.gov/portal/customize/LinkToRecord.aspx?altId=7133441-CN",
    "permitClass": "Single Family/Duplex",
    "permitClassMapped": "Residential",
    "permitTypeDesc": "New",
    "permitTypeMapped": "Building",
    "statusCurrent": "Scheduled",
    "description": "Construct new SFR/DADU. Reinstall garage door at existing SFR basement.",
    "estimatedProjectCost": 200000,
    "originalAddress": "7802 ROOSEVELT WAY NE",
    "originalCity": "SEATTLE",
    "originalState": "WA",
    "originalZip": "98115",
    "latitude": 47.68545121,
    "longitude": -122.31721508,
    "scrapedAt": "2026-05-13T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏗️ | **Every Seattle DCI permit.** Decades of filings, refreshed multiple times per day from the city's official open-data feed. |
| 🎯 | **Seven combinable filters.** Permit type, class, status, applied date range, ZIP, keyword. |
| 💵 | **Project cost and unit counts.** Estimated cost plus housing-units added and removed for every record. |
| 📍 | **Geocoded.** Lat/lon on every permit, ready to drop into Mapbox, Kepler, or QGIS. |
| 🛠️ | **Contractor and applicant.** Surface the parties behind each project for lead generation and competitive intel. |
| ⚡ | **Fast.** 1,000 permits in under 10 seconds via Socrata's SODA API. |
| 🚫 | **No login.** The data is public open data. No credentials, no rate-limit hassle. |

> 📊 Permit data is the leading indicator of construction activity, displacement, and neighborhood change in any U.S. city.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Seattle Permits Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All Seattle DCI permits** | **Live per run** | type, class, status, date, ZIP, keyword | ⚡ 2 min |
| Seattle DCI portal lookups | Free | Per permit | Live | UI search only | 🐢 Manual |
| Raw Socrata SoQL queries | Free | Full | Live | SoQL | 🛠️ Code required |
| Paid construction-data feeds | $300+/month | Bundled cities | Daily | Vendor-defined | ⏳ Hours |

Pick this Actor when you want clean Seattle permit data without writing a Socrata query yourself.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Seattle Building Permits Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a permit type, class, status, date range, ZIP, or keyword, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏗️ Developers and Contractors

- Spot every new commercial filing in your target submarket
- Track competitor pipeline and project values in real time
- Pull comparable cost-per-square-foot data for bids
- Identify multi-permit owners and likely repeat customers

</td>
<td width="50%" valign="top">

#### 📈 Real-Estate Analysts

- Track new-construction supply by ZIP and neighborhood
- Measure demolition rates and tear-down density
- Quantify housing-unit deltas city-wide month over month
- Build pipeline dashboards for prop-tech and investor decks

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🛠️ Trades and Suppliers

- Generate leads from newly issued permits before competitors call
- Filter by contractor company to map competitor activity
- Spot tenant-improvement projects in commercial corridors
- Track ECA and shoreline projects for specialty suppliers

</td>
<td width="50%" valign="top">

#### 🗞️ Civic Research and Journalism

- Investigate displacement patterns by mapping demolitions
- Quantify upzoning impact in specific neighborhoods
- Track institutional building expansions over time
- Build interactive maps for local-news urban coverage

</td>
</tr>
</table>

***

### 🔌 Automating Seattle Permits Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep downstream databases in sync automatically.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Urban-planning papers on permit volume and zoning policy
- Housing-economics theses with live filing data
- Reproducible studies on displacement and gentrification
- GIS coursework with geocoded municipal records

</td>
<td width="50%">

#### 🎨 Personal and creative

- Neighborhood watch dashboards for new construction
- Side projects mapping every demolition in your ZIP
- Local-history blogs documenting architectural turnover
- Hobby visualizations of the city's growth over time

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Housing-justice orgs tracking displacement filings
- Neighborhood councils monitoring large new projects
- Community land trusts spotting reuse opportunities
- Investigative journalism on permit-process equity

</td>
<td width="50%">

#### 🧪 Experimentation

- Train cost-estimation ML models on declared project costs
- Prototype agent pipelines that flag interesting projects
- Test geocoding and address-normalization toolchains
- Validate civic-tech product hypotheses with live data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Seattle%20Building%20Permits%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Seattle%20Building%20Permits%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Seattle%20Building%20Permits%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Seattle%20Building%20Permits%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick filters in the input form, click Start, and the Actor builds a Socrata SoQL query against `data.seattle.gov`, fetches matching permits in pages of 1,000, and emits one normalized record per permit. No browser automation, no captchas, no setup.

#### 🏗️ How far back does the data go?

Seattle DCI publishes its full permit history on data.seattle.gov, going back decades. The Actor reads whatever is currently exposed by the city's open-data feed.

#### 🔄 How fresh is the data?

The city refreshes the underlying open-data feed multiple times per day. Every run of this Actor fetches the latest data, so your dataset reflects current records as of run time.

#### 💵 Is the estimated project cost accurate?

Estimated project cost reflects what the applicant declared at the time of filing. It is a useful directional indicator but is not necessarily the final spend or the final assessed valuation.

#### 🏠 What do housing-unit fields mean?

`housingUnits` is the count after the project. `housingUnitsAdded` and `housingUnitsRemoved` quantify the delta. For a teardown with a single replacement house, you typically see `housingUnitsRemoved: 1` and `housingUnitsAdded: 1`.

#### 📅 Can I filter by issued date instead of applied date?

The Actor's date filter targets `applieddate`, which is the most consistent and complete date across the dataset. If you need issued, expired, or completed dates, run the Actor on a broader applied-date window and filter the dataset downstream.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync with new permits.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### ⚖️ Is this data legal to use?

Yes. Seattle building permit data is public open data published under the City of Seattle Open Data Policy. Republish and reuse with attribution to the City.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Seattle Permits Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notified when a new permit matches your filters
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe permits into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh Seattle permits into your CRM or analytics backend.

***

### 🔗 Recommended Actors

- [**🌉 San Francisco Open Data Scraper**](https://apify.com/parseforge/sf-open-data-scraper) - Same Socrata pattern, every SF dataset
- [**🌴 Los Angeles Open Data Scraper**](https://apify.com/parseforge/la-open-data-scraper) - Same Socrata pattern, every LA dataset
- [**🏠 Greatschools Scraper**](https://apify.com/parseforge/greatschools-scraper) - U.S. K-12 school ratings
- [**🏛️ James Edition Real Estate Scraper**](https://apify.com/parseforge/james-edition-real-estate-scraper) - Luxury real estate
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Press releases and corporate announcements

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more public-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the City of Seattle or the Seattle Department of Construction and Inspections. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Filter by Seattle DCI permit type description

## `permitClass` (type: `string`):

Filter by property use class

## `status` (type: `string`):

Filter by current status

## `appliedFrom` (type: `string`):

Lower bound for applieddate (inclusive)

## `appliedTo` (type: `string`):

Upper bound for applieddate (inclusive)

## `zip` (type: `string`):

Filter by original ZIP (e.g. '98101')

## `keyword` (type: `string`):

Full-text search across permit number, description and address

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/seattle-permits-scraper").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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seattle Building Permits Scraper",
        "description": "Scrape building permits from Seattle Open Data (Socrata). Filter by date, type, address, applicant, contractor. Get permit number, status, costs, units, descriptions. No API key required.",
        "version": "0.0",
        "x-build-id": "JTIs9V2eyacK4fAup"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~seattle-permits-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-seattle-permits-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~seattle-permits-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-seattle-permits-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~seattle-permits-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-seattle-permits-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "permitType": {
                        "title": "Permit type",
                        "enum": [
                            "Addition/Alteration",
                            "Change of Use Only - No Construction",
                            "Curb Cut",
                            "Deconstruction",
                            "Demolition",
                            "ECA Small Project Waiver",
                            "Environmentally Critical Area Exemption",
                            "Modification to Submittal Requirements",
                            "New",
                            "Relief from Prohibition on Steep Slope",
                            "Relocation",
                            "Shoreline Exemption",
                            "Shoreline Permit Exemption",
                            "Street Improvement Exception",
                            "Temporary",
                            "Tenant Improvement Pre-Approval",
                            "Tenant Improvment"
                        ],
                        "type": "string",
                        "description": "Filter by Seattle DCI permit type description"
                    },
                    "permitClass": {
                        "title": "Permit class",
                        "enum": [
                            "Commercial",
                            "Industrial",
                            "Institutional",
                            "Multifamily",
                            "Single Family/Duplex",
                            "Vacant Land",
                            "N/A"
                        ],
                        "type": "string",
                        "description": "Filter by property use class"
                    },
                    "status": {
                        "title": "Current status",
                        "enum": [
                            "Active",
                            "Additional Info Requested",
                            "Application Completed",
                            "Approved to Occupy",
                            "Awaiting Information",
                            "Canceled",
                            "Closed",
                            "Completed",
                            "Corrections Required",
                            "Corrections Submitted",
                            "Denied",
                            "Expired",
                            "Initiated",
                            "Inspections Completed",
                            "Issued",
                            "Pending",
                            "Phase Issued",
                            "Ready for Intake",
                            "Ready for Issuance",
                            "Reviews Completed",
                            "Reviews In Process",
                            "Scheduled",
                            "Scheduled and Submitted",
                            "Withdrawn"
                        ],
                        "type": "string",
                        "description": "Filter by current status"
                    },
                    "appliedFrom": {
                        "title": "Applied date from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Lower bound for applieddate (inclusive)"
                    },
                    "appliedTo": {
                        "title": "Applied date to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Upper bound for applieddate (inclusive)"
                    },
                    "zip": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "Filter by original ZIP (e.g. '98101')"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Full-text search across permit number, description and address"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
