# Canada New Incorporations - Federal Registry Open Data (`agentumgroup/ca-new-incorporations`) Actor

A new incorporation is a high-signal B2B lead: fresh budget, no incumbent vendor. Pull newly incorporated federal businesses from Corporations Canada open data (daily updates). Filter by province, date, keywords. Ideal for accountants, lawyers, SaaS, and HR tools.

- **URL**: https://apify.com/agentumgroup/ca-new-incorporations.md
- **Developed by:** [AgentumGroup](https://apify.com/agentumgroup) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 New Incorporations — Federal Registry (Open Data)

Extract newly incorporated Canadian federal businesses from the official **Corporations Canada** open-data registry — updated daily, zero scraping required.

A new incorporation is a high-signal B2B lead: fresh budget, buying decisions to make, no incumbent vendor. Use this Actor to get a rolling list of new companies every week for outreach by accountants, lawyers, insurance brokers, SaaS tools, office suppliers, and HR platforms.

### Quickstart (30 seconds)

1. Click **Try for free** above — no credit card required for your first run.
2. Set `incorporatedAfter` to 7 days ago (e.g. `2026-07-13`) and click **Start**.
3. Download results as JSON, CSV, or pipe them into your CRM via webhook.

**Typical first run:** 200–500 new corporations per week across all provinces in under 30 seconds.

For ongoing lead-gen, schedule weekly with `incorporatedAfter` set to 7 days ago — you get only the freshest companies automatically.

### What it does

Fetches the Government of Canada's daily-updated CSV exports of active federal corporations (Canada Business Corporations Act), filters by incorporation date and optional province or name keywords, and returns structured business records — newest first.

### Data source & licence

- **Source:** Corporations Canada / Innovation, Science and Economic Development Canada
- **Dataset:** [Federal Corporations open data](https://open.canada.ca/data/en/dataset/0032ce54-c5dd-4b66-99a0-320a7b5e99f2)
- **Licence:** [Open Government Licence – Canada](https://open.canada.ca/en/open-government-licence-canada) — permits copying, redistribution, and commercial use with attribution.
- **Update frequency:** Daily (CSVs published via ISED Canada)
- **Coverage:** ~642,000 active federal business corporations, all provinces and territories

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `registries` | string[] | `["federal"]` | Registries to fetch. Currently: `federal` (CBCA). |
| `incorporatedAfter` | date | `null` | Only corps incorporated on/after this date (YYYY-MM-DD). Recommended: `7 days ago` for weekly lead-gen runs. |
| `incorporatedBefore` | date | `null` | Only corps incorporated on/before this date. Leave blank for no upper bound. |
| `provinces` | string[] | `[]` (all) | Filter to specific provinces/territories by 2-letter code (e.g. `["ON","BC"]`). |
| `keywords` | string | `null` | Comma-separated keywords matched against corporate name (case-insensitive). |
| `includeOther` | boolean | `false` | Also fetch non-CBCA federal corps (co-ops, banks under Bank Act, etc.). |
| `maxRecords` | integer | `500` | Maximum total records to return. |

#### Example input — weekly new incorporations in Ontario

```json
{
  "incorporatedAfter": "2026-07-13",
  "provinces": ["ON"],
  "maxRecords": 200
}
````

#### Example input — tech companies incorporated this year

```json
{
  "incorporatedAfter": "2026-01-01",
  "keywords": "tech, software, digital, ai, data",
  "maxRecords": 1000
}
```

### Output

Each record in the dataset:

```json
{
  "registry": "federal",
  "source": "CBCA",
  "corporationNumber": "18145491",
  "businessNumber": "777123456",
  "corporateName": "ACME INNOVATIONS INC.",
  "corporateName2": null,
  "governingLegislation": "Canada Business Corporations Act",
  "status": "Active",
  "incorporatedDate": "2026-07-01",
  "yearOfLastAnnualFiling": null,
  "dateOfLastAnnualMeeting": null,
  "street": "100 King Street West",
  "street2": "Suite 200",
  "city": "Toronto",
  "provinceTerritory": "ON",
  "country": "CA",
  "postalCode": "M5X 1A9",
  "sourceUrl": "https://open.canada.ca/data/en/dataset/0032ce54-c5dd-4b66-99a0-320a7b5e99f2",
  "fetchedAt": "2026-07-19T00:00:00.000Z"
}
```

A `RUN_SUMMARY` key-value store record is also written with totals and per-registry status.

### Pricing

Pay-per-result on the Apify platform:

| What | Cost |
|---|---|
| Per run (start fee) | $0.01 |
| Per record returned | $0.002 |

**Worked examples:**

- 500 new corps (1 run): $0.01 + (500 × $0.002) = **$1.01**
- 1,000 records (1 run): $0.01 + (1,000 × $0.002) = **$2.01**
- Weekly schedule, 300 new corps/week: $0.01 + (300 × $0.002) = **$0.61/week** (~$2.64/month)

### Scheduled lead-gen workflow

1. Set `incorporatedAfter` to 7 days ago, `maxRecords` to 2000.
2. Schedule weekly via Apify's built-in scheduler.
3. Connect a webhook to your CRM or spreadsheet to receive new records automatically.

### Limitations

- **Federal corporations only.** Provincial-only incorporations (e.g. BC Ltd., Alberta Numbered Co.) are not in this dataset. Federal incorporation is common for companies operating across multiple provinces.
- **No direct contact info.** Incorporations data contains the registered address and business number — use the CRA Business Number to cross-reference other public databases.
- **Status = "Active"** at time of CSV publication. Companies dissolved or struck off between daily updates may briefly appear.

### FAQ

**How often is the data updated?**
Corporations Canada publishes updated CSVs daily. The Actor fetches the latest file on every run, so data is typically less than 24 hours old.

**Does this include provincial incorporations?**
No — only federally incorporated companies (CBCA). Provincial incorporations (BC Ltd., Alberta corp, Ontario Inc.) are not in the federal registry.

**Is this legal to use commercially?**
Yes. The data is published under the Open Government Licence — Canada, which explicitly permits commercial use with attribution.

**Who do I contact for support?**
Email manager@agentumgroup.com — typically replied to within 1 business day.

### Attribution

Contains information licensed under the [Open Government Licence – Canada](https://open.canada.ca/en/open-government-licence-canada).

# Actor input Schema

## `registries` (type: `array`):

Which corporation registries to fetch from. Currently: federal (CBCA — covers all provinces).

## `incorporatedAfter` (type: `string`):

Only include corporations incorporated on or after this date. For weekly lead-gen, set to the date 7 days ago. Leave blank to get all active corporations.

## `incorporatedBefore` (type: `string`):

Only include corporations incorporated on or before this date. Leave blank for no upper bound.

## `provinces` (type: `array`):

Limit results to these Canadian provinces or territories (2-letter codes). Leave empty for all.

## `keywords` (type: `string`):

Optional comma-separated keywords to match against the corporate name (case-insensitive). Example: "tech, software". Leave empty for all names.

## `includeOther` (type: `boolean`):

Also fetch non-CBCA federal corporations (co-operatives, banks under the Bank Act, etc.). Increases run time slightly.

## `maxRecords` (type: `integer`):

Maximum total number of corporation records to return across all registries.

## Actor input object example

```json
{
  "registries": [
    "federal"
  ],
  "provinces": [],
  "includeOther": false,
  "maxRecords": 500
}
```

# 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 = {
    "registries": [
        "federal"
    ],
    "provinces": [],
    "includeOther": false,
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentumgroup/ca-new-incorporations").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 = {
    "registries": ["federal"],
    "provinces": [],
    "includeOther": False,
    "maxRecords": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("agentumgroup/ca-new-incorporations").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 '{
  "registries": [
    "federal"
  ],
  "provinces": [],
  "includeOther": false,
  "maxRecords": 500
}' |
apify call agentumgroup/ca-new-incorporations --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentumgroup/ca-new-incorporations",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada New Incorporations - Federal Registry Open Data",
        "description": "A new incorporation is a high-signal B2B lead: fresh budget, no incumbent vendor. Pull newly incorporated federal businesses from Corporations Canada open data (daily updates). Filter by province, date, keywords. Ideal for accountants, lawyers, SaaS, and HR tools.",
        "version": "1.0",
        "x-build-id": "CZAdo0rGyvLcI4xKD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentumgroup~ca-new-incorporations/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentumgroup-ca-new-incorporations",
                "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/agentumgroup~ca-new-incorporations/runs": {
            "post": {
                "operationId": "runs-sync-agentumgroup-ca-new-incorporations",
                "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/agentumgroup~ca-new-incorporations/run-sync": {
            "post": {
                "operationId": "run-sync-agentumgroup-ca-new-incorporations",
                "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": {
                    "registries": {
                        "title": "Registries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which corporation registries to fetch from. Currently: federal (CBCA — covers all provinces).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "federal"
                            ],
                            "enumTitles": [
                                "Federal CBCA (all provinces)"
                            ]
                        },
                        "default": [
                            "federal"
                        ]
                    },
                    "incorporatedAfter": {
                        "title": "Incorporated after (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include corporations incorporated on or after this date. For weekly lead-gen, set to the date 7 days ago. Leave blank to get all active corporations."
                    },
                    "incorporatedBefore": {
                        "title": "Incorporated before (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include corporations incorporated on or before this date. Leave blank for no upper bound."
                    },
                    "provinces": {
                        "title": "Province / territory filter",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to these Canadian provinces or territories (2-letter codes). Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AB",
                                "BC",
                                "MB",
                                "NB",
                                "NL",
                                "NS",
                                "NT",
                                "NU",
                                "ON",
                                "PE",
                                "QC",
                                "SK",
                                "YT"
                            ],
                            "enumTitles": [
                                "Alberta",
                                "British Columbia",
                                "Manitoba",
                                "New Brunswick",
                                "Newfoundland and Labrador",
                                "Nova Scotia",
                                "Northwest Territories",
                                "Nunavut",
                                "Ontario",
                                "Prince Edward Island",
                                "Quebec",
                                "Saskatchewan",
                                "Yukon"
                            ]
                        },
                        "default": []
                    },
                    "keywords": {
                        "title": "Corporate name keyword filter",
                        "type": "string",
                        "description": "Optional comma-separated keywords to match against the corporate name (case-insensitive). Example: \"tech, software\". Leave empty for all names."
                    },
                    "includeOther": {
                        "title": "Include other federal corporations",
                        "type": "boolean",
                        "description": "Also fetch non-CBCA federal corporations (co-operatives, banks under the Bank Act, etc.). Increases run time slightly.",
                        "default": false
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum total number of corporation records to return across all registries.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```