# Canada Business Entity Search (`lentic_clockss/canada-business-search`) Actor

Search 1.55 million Canadian federal corporations from ISED Corporations Canada via full-text keyword search.

- **URL**: https://apify.com/lentic\_clockss/canada-business-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, Business
- **Stats:** 1 total users, 0 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 Business Entity Search

Search over **1.55 million Canadian federal corporations** registered with ISED Corporations Canada. This Apify Actor provides instant full-text search across the entire federal company registry — the most comprehensive Canadian corporation lookup tool available on the Apify platform.

### What Is This Actor?

The Canada Business Entity Search Actor connects to the federal corporation database maintained by Innovation, Science and Economic Development Canada (ISED). It enables you to search Canadian business entities by keyword and retrieve structured data including company name, status, registered address, province, business number, and incorporation date.

Whether you need to verify a Canadian company exists, look up its registration status, or gather data on businesses in a specific industry, this Actor delivers results in seconds. There are currently **zero competitors** on Apify offering equivalent access to the ISED Corporations Canada registry, making this the only tool of its kind on the platform.

### Data Coverage

This Actor searches a single authoritative source:

- **Federal Corporations (ca_federal_corporations)** — 1.55 million corporations registered under the Canada Business Corporations Act (CBCA) through ISED Corporations Canada. This covers all federally incorporated businesses across every province and territory.

Each record includes the following fields:

| Field | Description |
|-------|-------------|
| `license_id` | Unique corporation identifier |
| `business_name` | Registered legal name of the corporation |
| `license_type` | Type of registration |
| `status` | Current status (Active, Dissolved, etc.) |
| `address` | Registered street address |
| `city` | City of registration |
| `state` | Province or territory |
| `zip_code` | Postal code |
| `country` | Country (Canada) |
| `owner_name` | Business Number (BN) assigned by CRA |
| `issue_date` | Date of incorporation |
| `source_jurisdiction` | Originating jurisdiction |

### Use Cases

#### KYB (Know Your Business) Compliance

Financial institutions, fintech companies, and payment processors need to verify that a business is legitimately registered before onboarding them as clients. This Actor lets compliance teams quickly confirm a Canadian corporation's existence, status, and registration details — a critical step in KYB workflows. Automate your business verification pipeline by integrating this Actor into your onboarding process.

#### Due Diligence

Investors, law firms, and M&A advisory teams conducting due diligence on Canadian companies can use this Actor to verify corporate registration details, confirm active status, and cross-reference business numbers. Pull structured data directly into your research workflow instead of manually searching government websites.

#### Market Research and Competitor Analysis

Researchers and business analysts can search the federal corporation registry by industry keywords to identify competitors, map market landscapes, and discover new entrants. With 1.55 million corporations indexed, you can uncover businesses operating in any sector across Canada. Use keyword searches like "fintech", "cannabis", "mining", or "artificial intelligence" to find relevant companies and build comprehensive market maps.

#### Lead Generation

Sales and business development teams targeting Canadian businesses can use this Actor to build prospect lists based on keyword searches. Find companies in specific industries, verify their active status, and extract contact addresses for outreach campaigns. Combine with other Apify Actors to enrich the data further.

#### Academic and Policy Research

Researchers studying Canadian business formation trends, regional economic development, or corporate demographics can extract bulk data from the federal registry. Analyze incorporation dates to track business creation over time, examine geographic distribution across provinces, or study dissolution rates by sector.

### How to Use

#### Input Parameters

- **keyword** (required): The search term to look up in the federal corporation registry. Examples: "Shopify", "Toronto consulting", "blockchain".
- **maxResults** (optional): Maximum number of records to return. Defaults to 50, maximum is 200.

#### Running the Actor

1. Set your `SIP_API_KEY` as an environment variable in the Actor's settings on Apify Console.
2. Provide a search keyword in the input.
3. Run the Actor. Results are saved to the default dataset.

#### Example Input

```json
{
    "keyword": "Shopify",
    "maxResults": 50
}
````

#### Example Output

```json
{
    "license_id": "1234567",
    "business_name": "SHOPIFY INC.",
    "license_type": "Federal Corporation",
    "status": "Active",
    "address": "151 O'Connor Street",
    "city": "Ottawa",
    "state": "ON",
    "zip_code": "K2P 2L8",
    "country": "CA",
    "owner_name": "BN123456789",
    "issue_date": "2004-09-28",
    "source_jurisdiction": "Federal"
}
```

### Integration and Automation

This Actor works seamlessly with the Apify platform's scheduling and integration features:

- **Schedule regular runs** to monitor new incorporations matching your keywords.
- **Use webhooks** to trigger downstream workflows when new results are found.
- **Export data** in JSON, CSV, or Excel format directly from the Apify Console.
- **Connect via API** to integrate results into your own applications, dashboards, or databases.

### Data Source

All data originates from **ISED Corporations Canada**, the official federal corporate registry maintained by Innovation, Science and Economic Development Canada. The database is regularly updated to reflect new incorporations, status changes, and dissolutions.

### Why Choose This Actor?

- **Comprehensive**: 1.55 million federal corporations — the complete ISED registry.
- **Fast**: Full-text search returns results in seconds.
- **Structured**: Clean, consistent JSON output ready for analysis or integration.
- **Unique**: The only Canadian federal corporation search tool available on Apify.
- **Reliable**: Built on official government data from ISED Corporations Canada.

Start searching Canadian federal corporations today. Whether you need a quick Canadian corporation lookup for compliance, a bulk export for market research, or automated monitoring for competitive intelligence, this Actor has you covered.

# Actor input Schema

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

Keyword to search for in Canadian federal corporation records.

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

Maximum number of results to return.

## Actor input object example

```json
{
  "keyword": "Shopify",
  "maxResults": 50
}
```

# Actor output Schema

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

List of Canadian federal corporation records.

# 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 = {
    "keyword": "Shopify"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/canada-business-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 = { "keyword": "Shopify" }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/canada-business-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 '{
  "keyword": "Shopify"
}' |
apify call lentic_clockss/canada-business-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada Business Entity Search",
        "description": "Search 1.55 million Canadian federal corporations from ISED Corporations Canada via full-text keyword search.",
        "version": "0.1",
        "x-build-id": "nCjGfZvBD0v8IAQm6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~canada-business-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-canada-business-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-business-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-canada-business-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-business-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-canada-business-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Keyword to search for in Canadian federal corporation records."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of results to return.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```