# Canadian Trademarks Scraper (`automation-lab/canadian-trademarks-database-search`) Actor

Search official Canadian trademarks by mark, owner or application and registration identifiers. Export status, Nice classes, owner, goods and services, dates and source links for clearance research and portfolio monitoring.

- **URL**: https://apify.com/automation-lab/canadian-trademarks-database-search.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.36 / 1,000 trademark exporteds

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Canadian Trademarks Scraper

Search **Canadian trademarks** in the official Canadian Trademarks Database and export structured application records. Look up a mark, current owner, application number or registration number, then optionally include public owner details, goods and services, filing dates and registration dates.

Built for trademark professionals, brand owners and research teams preparing clearance research or comparing portfolio snapshots. This is a public-record extraction tool, not a legal opinion or a guarantee that a proposed mark is available.

### What does this Actor do?

The Actor queries the official CIPO search service at `ised-isde.canada.ca`. Each exported row represents one unique application. It preserves the official status text and Nice classes and provides a link back to the original record.

Choose a single query and search field per run. Detail enrichment is enabled by default. Turn it off when you only need fast application, mark, status and class lookup.

### Who is it for?

Trademark professionals preparing record reviews, brand owners checking Canadian portfolios, and data teams joining register snapshots to internal brand inventories. Results require human review; this tool does not determine rights or legal availability.

### Why use it?

- Move repeat searches into consistent JSON, CSV or Excel exports.
- Keep application identifiers as strings, preserving leading zeroes.
- Compare status and owner snapshots using application number as the stable key.
- Retain official links and retrieval timestamps for source review.
- Control the number of exported records and optional detail requests.

No account, cookies, API key for the source, browser or proxy configuration is required. Your Apify token is needed only when invoking the Actor through the Apify API.

### Getting started

1. Enter a query, such as `maple`.
2. Choose trademark text, current owner, application number or registration number.
3. Set `maxItems` to the maximum number of records to export.
4. Keep `includeDetails` enabled for owner, dates and goods/services.
5. Run the Actor and open the dataset tab.
6. Download JSON, CSV or Excel, or retrieve the dataset through the API.

```json
{
  "query": "maple",
  "searchField": "mark",
  "maxItems": 10,
  "includeDetails": true
}
```

### Search Canadian trademarks

The mark and owner fields use the official search engine's word/query semantics. They are not a guaranteed literal substring search or whole-field equality check. Case, token handling, ranking and query operators are controlled by CIPO. Inspect returned records before treating a query as a legal clearance search.

For exact application lookup, use all seven digits, including leading zeroes where applicable, and retain any division suffix (for example `2075108-01`):

```json
{"query":"1767735","searchField":"applicationNumber","maxItems":1}
```

For registration lookup:

```json
{"query":"TMA1013413","searchField":"registrationNumber","maxItems":1}
```

For current owner search:

```json
{"query":"MAPLE Business Council","searchField":"owner","maxItems":10}
```

### Input parameters

| Parameter | Default | Behavior |
|---|---|---|
| `query` | Required | One query, 1–200 characters after outer whitespace trimming. |
| `searchField` | `mark` | `mark`, `owner`, `applicationNumber` or `registrationNumber`. |
| `maxItems` | `10` | Global maximum unique applications, 1–1000. Zero/unlimited is not supported. |
| `includeDetails` | `true` | Enrich each accepted record from its official English detail page. |

Unsupported fields fail validation; status and Nice-class filters are not exposed. Export classes/status and filter downstream, or use a more specific supported query. The Actor does not combine multiple search fields in one run.

The source receives the requested result cap. Deduplication occurs by application number; duplicate/rejected hits are not refilled. Source ranking applies. When `totalFound` exceeds `maxItems`, the dataset is a capped snapshot, not an exhaustive export. There is no promise of pagination beyond the official 1000-result cap.

### Extracted data

| Field | Meaning |
|---|---|
| `applicationNumber` | Source identifier, including leading zeroes and any division suffix such as `-01`, retained as a string. |
| `mark` | Official trademark text. |
| `status` | Current CIPO status description. |
| `markType` | Word, design, standard characters or other source type. |
| `niceClasses` | List of source Nice class numbers. |
| `registrationNumber` | Registration identifier when present in details. |
| `owner` | Public registered owner/applicant and address when present. |
| `filingDate` | Filing date from details, when present. |
| `registrationDate` | Registration date from details, when present. |
| `expiryDate` | Registration expiry date from details, when present. |
| `goodsAndServices` | Public statements with source class labels, when present. |
| `detailsIncluded` | Whether requested enrichment completed. |
| `sourceUrl` | Official English record URL. |
| `query`, `searchField` | Input context for downstream tracking. |
| `totalFound` | Official total matches before the export cap. |
| `scrapedAt` | ISO retrieval timestamp. |

Detail fields are null when details are disabled or when the source does not publish the value. An empty class list is possible for older or special records. Goods/services are source text, not an AI classification or summary.

### Output example

A verified public record returned by application lookup, with owner text shortened here for readability:

```json
{
  "applicationNumber": "1767735",
  "mark": "MAPLE",
  "status": "REGISTERED",
  "markType": "Word",
  "niceClasses": [35],
  "registrationNumber": "TMA1013413",
  "owner": "MAPLE Business Council, a California corporation ...",
  "filingDate": "2016-02-12",
  "registrationDate": "2019-01-21",
  "expiryDate": "2034-01-21",
  "goodsAndServices": "Services (Nice class & Statement): 35 (1) Services for promoting and provision of foreign trade information ...",
  "detailsIncluded": true,
  "sourceUrl": "https://ised-isde.canada.ca/cipo/trademark-search/1767735?lang=eng",
  "query": "1767735",
  "searchField": "applicationNumber",
  "totalFound": 1,
  "scrapedAt": "2026-10-23T15:20:00.000Z"
}
```

The statements above are abbreviated for documentation only; the Actor exports the parsed source statements, not these ellipses.

### How much does it cost to export Canadian trademarks?

Pay-per-event pricing includes a **$0.005 start fee per valid run** plus a fee for each unique trademark exported. Optional public detail enrichment has no separate event charge. No item charge is issued for empty matches, duplicates or records that fail parsing.

| Apify tier | Per trademark |
|---|---:|
| FREE | $0.00644 |
| BRONZE | $0.0056 |
| SILVER | $0.004368 |
| GOLD | $0.00336 |
| PLATINUM | $0.00336 |
| DIAMOND | $0.00336 |

BRONZE total-run examples including one start fee: n=1 → $0.0106; n=10 → $0.061; n=100 → $0.565. A valid search with no matches incurs only the start fee. Invalid input fails before the start charge. Apify displays the applicable tier and spending limit; verify it before running. These are Actor event prices, not a claim that all Apify subscription or platform usage is included.

### Reliability and limits

Search requests use structured official JSON; details use public English HTML. Detail requests are sequential to limit source load and memory. Transient network errors, HTTP 429 and 5xx receive up to three attempts with bounded backoff. Other HTTP errors and unexpected content fail clearly.

If an upstream error occurs after some rows were exported, those rows remain partial output and may have been charged. A failed run is not a completed full export. A legitimate no-result search succeeds with an empty dataset. No CAPTCHA-solving, signed-in records, images, document downloads or paid proxy fallback is included.

For broad searches, increase the Actor timeout if needed. The default is 300 seconds; 1000 detailed records may require longer depending on source response time. Narrow queries improve relevance and reduce work. `totalFound` measures source matches, not guaranteed accessible/exported records.

### Integrations and recurring monitoring

Schedule repeat searches on Apify, then send the dataset to a spreadsheet, database or a webhook consumer. Compare `applicationNumber`, `status`, `owner` and dates against your previous snapshot. Store snapshots in your own database if you need historical changes.

The Actor itself does not maintain watch state, send alerts, determine similarity risk or declare legal availability. Scheduling and change detection are downstream workflows. Export untransformed JSON for nested `niceClasses`; use CSV or Excel for review.

### API access

Start a run once and retain its returned run ID and storage IDs. Poll that same run until terminal, then read the dataset. Never restart merely to check status.

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"maple","maxItems":10,"includeDetails":true}' \
  'https://api.apify.com/v2/acts/automation-lab~canadian-trademarks-database-search/runs'
```

JavaScript with the official client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/canadian-trademarks-database-search')
  .call({ query: 'maple', maxItems: 10, includeDetails: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/canadian-trademarks-database-search').call(
    run_input={'query': 'maple', 'maxItems': 10, 'includeDetails': True})
rows = client.dataset(run['defaultDatasetId']).list_items(limit=10).items
print(rows)
```

### MCP use

Select the stable Actor-specific tool set:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/canadian-trademarks-database-search"
```

Claude Desktop, Cursor and VS Code users can use equivalent configuration in clients supporting HTTP MCP:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/canadian-trademarks-database-search"
    }
  }
}
```

Authenticate using the client's supported Apify authorization. Discover actual tool names and argument schemas with `tools/list`. Actor selection also exposes run, dataset, key-value-store and abort helpers; discovery alone is not permission to execute them.

Example prompt: “Search Canadian trademarks for maple, export at most 10 records with public details, and show application numbers, status and source links. Do not give a legal clearance opinion.”

Start once, retain the returned run ID, and follow that same run. `call-actor` may wait at most 45 seconds; configure the client timeout above its selected wait plus transport margin. For nonterminal runs, check `get-actor-run` with bounded 2/4/8-second backoff capped at 10 seconds and a total 120-second deadline. At deadline report pending with the run ID. On client timeout recover the known run, never blindly start another.

After success, read bounded `get-dataset-items` pages of 20 source rows using explicit offset, limit and needed fields. A suggested consumer budget is 100 rows or 64 KiB of serialized UTF-8 results admitted to model context, whichever comes first. Enforce the byte ceiling host-side, omit/summarize oversize rows with disclosure, and report continuation offsets and partial/truncated status. Clients without interception cannot guarantee a byte ceiling. Keep complete exports outside model context. These are consumer-context limits, not Actor collection limits; no universal token-saving claim is made.

### Legality and responsible use

This Actor is independent and is not affiliated with or endorsed by CIPO or the Government of Canada. Review official records and consult qualified counsel for clearance decisions. Follow source terms and applicable data-protection obligations. Public owner addresses can contain personal data: collect and retain only what your lawful workflow requires.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Do not submit confidential search terms or secrets that your workflow is not authorized to process. The Actor uses no AI at runtime. Apify stores datasets, input and logs under your account's retention settings; delete them through Apify storage controls when no longer required. No separate business cache is maintained. Source queries go to CIPO; sanitized failure diagnostics go to our private GlitchTip instance. For assistance, open an issue on this Actor's Apify page with the run ID, excluding secrets.

### FAQ and troubleshooting

**Does a matching record mean infringement?** No. This is data extraction, not a legal determination or risk score.

**Why did I receive fewer records than totalFound?** `maxItems`, source ranking, duplicate removal and the official cap restrict the export. Use narrower queries; do not assume exhaustive register coverage.

**Why are owner or goods/services null?** Detail enrichment may be disabled, or the public record may omit the field. Failed enrichment fails the run rather than silently reporting null as success.

**Why did my run fail?** Check the run log for input validation, HTTP status or source-shape errors. Correct malformed identifiers. For temporary source errors, retry later; avoid repeated immediate runs.

**Can this watch new filings or send alerts?** Not by itself. Schedule repeated snapshots and compare them downstream. Historical revisions and built-in watch state are not included.

### Related Actors

For dispute research rather than Canadian application clearance, see our [USPTO TTAB Proceedings Search](https://apify.com/automation-lab/uspto-ttab-proceedings-search). It covers US dispute proceedings, not this Canadian register. Use separate workflows for those different jurisdictions and record types.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/canadian-trademarks-database-search/changelog.md

# Actor input Schema

## `query` (type: `string`):

Required search text passed to the official field-specific search engine. Mark and owner searches use the source's word/query syntax, not guaranteed substring or whole-field equality. Application numbers require seven digits including leading zeroes, with an optional two-digit division suffix such as -01; registration identifiers accept letters followed by digits. Outer whitespace is removed. One query per run.

## `searchField` (type: `string`):

Choose the official field searched by query: trademark text, current owner name, application number or registration number. Application-number results are additionally checked for exact identity. This is not a combined multi-filter search.

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

Global maximum unique application records exported per run, from 1 to 1000; default 10. Zero/unlimited is unsupported. Requests only this many source hits, deduplicates by application number and does not refill rejected or duplicate hits. Official ranking and a 1000-result cap apply; totalFound may exceed exported records. No exhaustive pagination is promised.

## `includeDetails` (type: `boolean`):

Default true: fetch each accepted official detail page for registration number, owner, goods/services and dates where present. False returns search-list fields only and leaves all enrichment fields null. A failed enrichment stops the run rather than silently claim completeness; earlier exported rows can remain partial output.

## Actor input object example

```json
{
  "query": "maple",
  "searchField": "mark",
  "maxItems": 10,
  "includeDetails": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

Export records as JSON, CSV or Excel from the run dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "maple"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/canadian-trademarks-database-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 = { "query": "maple" }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/canadian-trademarks-database-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "maple"
}' |
apify call automation-lab/canadian-trademarks-database-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/canadian-trademarks-database-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/b8HZ3NKcCSgvdUIIO/builds/iL1ilErEVvXCjRRBW/openapi.json