# canada411.ca (`fayoussef/canada411-ca`) Actor

Our canada411.ca scraper effortlessly gathers URLs from all pages and extracts contact information from each listing.

- **URL**: https://apify.com/fayoussef/canada411-ca.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 95 total users, 8 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

## Canada411.ca Scraper — Extract Business & Personal Contact Data from Canada411

Scrape Canada411.ca contact listings at scale with this actor that paginates through all available result pages and extracts name, phone number, address, and profile URL for every entry. Built for B2B lead generation teams, sales agencies, local marketing firms, and researchers who need structured Canadian contact data without manual lookup.

### What you get

**Contact info**
- `name` — full name of the individual or business
- `phone` — phone number as listed
- `address` — full street address including city and province
- `source_url` — direct link to the Canada411 profile page

### Sample output

```json
{
  "name": "Alex Tremblay",
  "phone": "416-555-1234",
  "address": "123 Example St, Toronto, ON",
  "source_url": "https://www.canada411.ca/res/1234567890.html"
}
````

### Use cases

- B2B sales agencies building targeted prospect lists by profession and city (doctors, lawyers, accountants)
- Local service businesses (cleaning, plumbing, HVAC) building outreach lists for a specific region
- Marketing firms segmenting Canadian contacts by province or city for direct mail or phone campaigns
- Recruiters sourcing contact information for independent professionals in a specific field
- Insurance and financial services companies researching regional contact density for market entry
- Researchers mapping the distribution of professional services across Canadian cities

### Pricing

| Fee | Amount |
|---|---|
| Results | $0.20 / 1,000 results |

**Real example:** Pulling 1,000 vehicle listings costs $0.20 in usage charges.

First results are free — test before subscribing.

### How it works

- Input one or more Canada411.ca search URLs (name + location filter)
- Actor follows all "Next" pagination links until results are exhausted or `max_pages` limit is reached
- Multiple start URLs are processed in parallel for speed
- Failed requests are retried automatically with logged error handling
- Export results as JSON, CSV, or Excel from the Apify dataset

### Why this scraper

- Handles full pagination automatically — no manual page-by-page URL construction needed
- Processes multiple search URLs concurrently, cutting total runtime significantly on large lists
- Returns a clean, flat record (name, phone, address, URL) that drops directly into any CRM or spreadsheet
- Modular structure makes it straightforward to extend with additional fields if Canada411 surfaces more data
- No proxy configuration required; uses Apify's proxy service by default

### Input example

```json
{
  "start_urls": [
    { "url": "https://www.canada411.ca/search/?stype=si&what=dentist&where=calgary" }
  ],
  "max_pages": 5,
  "max_concurrency": 10
}
```

### FAQ

**Can I search for both businesses and individuals?**
Yes. Canada411 has separate search modes for businesses (`stype=sb`) and individuals (`stype=si`). Use whichever URL type matches your need.

**Does the scraper extract email addresses?**
Canada411 does not display email addresses publicly, so the actor returns only the fields Canada411 exposes: name, phone, address, and profile URL.

**What output formats are available?**
JSON, CSV, Excel, XML, and JSONL — all downloadable from the Apify dataset UI or via API.

**How do I limit results to a specific city or province?**
Use Canada411's own search filters in the URL (e.g., `where=montreal` or `where=bc`). The actor scrapes exactly what that URL returns.

**Does it support scheduling?**
Yes. Use Apify's built-in scheduler for recurring runs on any cron schedule.

**Can I use this via API or MCP?**
Yes. The actor is callable via the Apify REST API and available as an MCP server for AI agents (Claude, ChatGPT, Cursor).

**Can I scrape multiple search queries in one run?**
Yes. Add multiple URLs to `start_urls` and the actor processes them all in parallel.

### Use via API or MCP

Call this actor via the Apify REST API or as an MCP server for AI agents (Claude, ChatGPT, Cursor):

```
https://mcp.apify.com/actors/fayoussef/canada411-ca
```

Full API docs: <https://docs.apify.com/api/v2>

### Need a custom scraper?

Need data from other Canadian directories, enriched with email or LinkedIn data, or delivered on a schedule? Visit [automationbyexperts.com](https://automationbyexperts.com) for custom builds, retainers, and data-as-a-service.

# Actor input Schema

## `what` (type: `string`):

Name of the person or business (e.g., 'Alex Raymond')

## `where` (type: `string`):

Location (e.g., 'Toronto, ON'). Can be left empty for a national search.

## `start_urls` (type: `array`):

Alternatively, provide full Canada411 URLs here.

## `max_pages` (type: `integer`):

How many pages the scraper should go through for each individual search. Leave empty for all pages.

## `proxy_url` (type: `string`):

Use your own proxy URL or leave it empty to use Apify proxies.

## Actor input object example

```json
{
  "what": "alex",
  "where": "Toronto"
}
```

# Actor output Schema

## `results` (type: `string`):

Canada411 scraper

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

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/canada411-ca").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 = { "proxy_url": "" }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/canada411-ca").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 '{
  "proxy_url": ""
}' |
apify call fayoussef/canada411-ca --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "canada411.ca",
        "description": "Our canada411.ca scraper effortlessly gathers URLs from all pages and extracts contact information from each listing.",
        "version": "0.0",
        "x-build-id": "QN7M69dpRgSlRfn7L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~canada411-ca/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-canada411-ca",
                "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/fayoussef~canada411-ca/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-canada411-ca",
                "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/fayoussef~canada411-ca/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-canada411-ca",
                "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": [
                    "what",
                    "where"
                ],
                "properties": {
                    "what": {
                        "title": "Who / What",
                        "type": "string",
                        "description": "Name of the person or business (e.g., 'Alex Raymond')",
                        "default": "alex"
                    },
                    "where": {
                        "title": "Where",
                        "type": "string",
                        "description": "Location (e.g., 'Toronto, ON'). Can be left empty for a national search.",
                        "default": "Toronto"
                    },
                    "start_urls": {
                        "title": "Direct Start URLs",
                        "type": "array",
                        "description": "Alternatively, provide full Canada411 URLs here.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "max_pages": {
                        "title": "Maximum Pages per Search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many pages the scraper should go through for each individual search. Leave empty for all pages."
                    },
                    "proxy_url": {
                        "title": "Custom Proxy URL",
                        "type": "string",
                        "description": "Use your own proxy URL or leave it empty to use Apify proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
