# Canada Building Permits Data API (`lentic_clockss/canada-building-permits-search`) Actor

Search Canadian building permits across 4 major cities (Calgary, Edmonton, Toronto, Vancouver) via SIP API. Access 280K+ permit records including contractor names, project costs, and permit details.

- **URL**: https://apify.com/lentic\_clockss/canada-building-permits-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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

## Canada Building Permits Search

Search and extract Canadian building permits data from four major cities — Calgary, Edmonton, Toronto, and Vancouver. This Apify Actor provides instant access to over 280,000 building permit records through the SIP API, covering residential, commercial, and industrial construction projects across Canada.

### Why Use Canada Building Permits Search?

Accessing Canada building permits data has traditionally required navigating multiple municipal portals, each with different formats, search interfaces, and export limitations. This Actor eliminates that friction by unifying building permit records from four of Canada's largest cities into a single, searchable interface. Whether you are a contractor looking for upcoming projects, a real estate investor analyzing construction trends, or a researcher studying urban development, this tool delivers the data you need in seconds.

There are currently **zero competitors** on the Apify Store offering a unified Canadian building permits search tool. This is the first and only Actor that aggregates construction permit data across multiple Canadian municipalities into one streamlined workflow.

### Supported Cities and Data Coverage

This Actor searches Canadian construction permits across four major metropolitan areas:

- **Calgary, AB** (`ca_calgary_building_permits`) — Alberta's largest city and a major hub for both residential and commercial construction. Calgary's building permits cover everything from downtown high-rise developments to suburban residential projects across the city's rapidly expanding communities.

- **Edmonton, AB** (`ca_edmonton_building_permits`) — Alberta's capital city with a thriving construction sector. Edmonton building permits include data on municipal infrastructure projects, residential developments, and commercial construction across the greater Edmonton area.

- **Toronto, ON** (`ca_toronto_building_permits`) — Canada's largest city with **230,000+ building permit records**. Toronto building permits represent one of the most comprehensive construction datasets in North America, covering the Greater Toronto Area's massive residential, commercial, and mixed-use development pipeline. Toronto's construction market is among the busiest in the continent, making this dataset invaluable for market analysis.

- **Vancouver, BC** (`ca_vancouver_building_permits`) — British Columbia's largest city with **50,000+ building permit records**. Vancouver building permits capture the city's dynamic construction landscape, from luxury residential towers to commercial developments across Metro Vancouver.

Combined, these four cities provide access to over **280,000 total building permit records**, making this one of the largest searchable Canadian construction permits datasets available through any API.

### What Data Can You Find?

Canadian building permits typically include rich details about construction projects:

- **Contractor names** — Identify which contractors and builders are active in each market. Track contractor activity across cities to find the most prolific builders in Canada.
- **Project costs** — Access estimated and actual project costs to understand construction spending patterns. Analyze project costs by city, permit type, and time period.
- **Permit types** — Filter by residential, commercial, industrial, demolition, and renovation permits. Understand the mix of construction activity in each city.
- **Project descriptions** — Read detailed descriptions of what each permit covers, from simple renovations to major new construction projects.
- **Location data** — Find permits by address, neighborhood, or area within each city.
- **Dates and status** — Track when permits were issued, their current status, and project timelines.

### Use Cases

#### Real Estate Investment and Market Research
Analyze Canadian construction permits to identify emerging neighborhoods, track development density, and spot investment opportunities before they become obvious. Compare construction activity across Calgary, Edmonton, Toronto, and Vancouver to find the hottest markets.

#### Contractor and Supplier Lead Generation
Use building permit data to identify active contractors, upcoming projects, and potential customers for construction materials and services. Search for specific project types like 'renovation', 'commercial', or 'residential' to find targeted leads.

#### Urban Planning and Academic Research
Study construction trends across major Canadian cities. Analyze how building permit volumes, project types, and costs change over time. Compare urban development patterns between Alberta, Ontario, and British Columbia.

#### Competitive Intelligence
Track competitor construction projects, monitor new developments in your market area, and stay ahead of industry trends by analyzing Canadian building permits data in real time.

### Input Configuration

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `keyword` | string | Search keyword (e.g., 'renovation', 'commercial', 'residential') | `renovation` |
| `cities` | array | Cities to search: calgary, edmonton, toronto, vancouver | All 4 cities |
| `maxResults` | integer | Maximum results per city (up to 200) | 50 |

### Example Input

```json
{
    "keyword": "renovation",
    "cities": ["toronto", "vancouver"],
    "maxResults": 100
}
````

### Example Output

Each result includes the city, product identifier, and the full permit record data:

```json
{
    "city": "toronto",
    "product_id": "ca_toronto_building_permits",
    "data": {
        "permit_number": "...",
        "description": "Interior renovation of commercial space",
        "contractor": "...",
        "estimated_cost": "...",
        "address": "...",
        "status": "..."
    }
}
```

### Setup and Authentication

This Actor requires a SIP API key for authentication. Set the `SIP_API_KEY` environment variable in your Actor configuration before running. The API key is passed via the `X-API-Key` header to the SIP data API.

1. Obtain your SIP API key from your SIP account.
2. Add `SIP_API_KEY` as an environment variable in the Actor's settings on Apify.
3. Configure your search parameters and run the Actor.

### Performance Notes

- Toronto's dataset contains 230,000+ records, so broad keyword searches may return many results. Use the `maxResults` parameter to control output volume.
- Vancouver's 50,000+ records provide excellent coverage of BC's construction market.
- The Actor searches cities sequentially to respect API rate limits and ensure reliable data retrieval.
- All API calls use a 30-second timeout to handle large result sets gracefully.

### Tags

Canada building permits, Canadian construction permits, Toronto building permits, Calgary permits, Edmonton building permits, Vancouver building permits, construction data, building permit search, Canadian real estate data, contractor leads, construction market research, Apify Actor

### Use as MCP Tool (AI Agent Integration)

This Actor works as an MCP tool — AI agents (Claude, GPT, Cursor) can discover and run it automatically.

#### Quick setup (Claude Desktop / Cursor / VS Code)

Add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Then ask your AI: *"Search for Toronto renovation in Canadian building permits"*

#### Direct API call

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lentic_clockss/canada-building-permits-search").call(
    run_input={"searchTerms": ["Toronto"], "maxResultsPerSource": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Other Data API Actors

- [US Business Entity Data API](https://apify.com/lentic_clockss/us-business-entity-search)
- [Australia Government Data API](https://apify.com/lentic_clockss/australia-data-search)
- [UK Government Data API](https://apify.com/lentic_clockss/uk-data-search)

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search (e.g. 'renovation', 'commercial', 'residential'). Each term is searched across Calgary, Edmonton, Toronto, and Vancouver in parallel.

## `maxResultsPerSource` (type: `integer`):

Maximum records to return per city (gateway caps at 200).

## Actor input object example

```json
{
  "searchTerms": [
    "renovation"
  ],
  "maxResultsPerSource": 50
}
```

# Actor output Schema

## `records` (type: `string`):

Building permit search results from selected Canadian cities.

# 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 = {
    "searchTerms": [
        "renovation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/canada-building-permits-search").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 = { "searchTerms": ["renovation"] }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/canada-building-permits-search").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 '{
  "searchTerms": [
    "renovation"
  ]
}' |
apify call lentic_clockss/canada-building-permits-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada Building Permits Data API",
        "description": "Search Canadian building permits across 4 major cities (Calgary, Edmonton, Toronto, Vancouver) via SIP API. Access 280K+ permit records including contractor names, project costs, and permit details.",
        "version": "0.1",
        "x-build-id": "xzF2Zw2CZy06sSnsv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~canada-building-permits-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-canada-building-permits-search",
                "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/lentic_clockss~canada-building-permits-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-canada-building-permits-search",
                "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/lentic_clockss~canada-building-permits-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-canada-building-permits-search",
                "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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search (e.g. 'renovation', 'commercial', 'residential'). Each term is searched across Calgary, Edmonton, Toronto, and Vancouver in parallel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per city",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum records to return per city (gateway caps at 200).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```