# RBQ Quebec Contractor Licence Scraper — Phone, Email, NEQ (`scrapersdelight/rbq-quebec-licence-register-scraper`) Actor

Every active Régie du bâtiment du Québec contractor licence, one row per licence: phone, email, address, NEQ, sub-categories, bonding company and bond amount. 54,000+ licences from the RBQ's daily open data. Filter by trade, region, city.

- **URL**: https://apify.com/scrapersdelight/rbq-quebec-licence-register-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.40 / 1,000 per licence returneds

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/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

## RBQ Quebec Contractor Licence Scraper — Phone, Email, NEQ

Every **active contractor licence** issued by the **Régie du bâtiment du Québec (RBQ)**, as one clean row per
licence: business name, trade names, **phone**, **email**, address, **NEQ**, legal status, every licence
sub-category with its official label, the **bonding company and bond amount**, issue date and restriction
status. **54,225 licences** in the register on 2026-09-22; **49,764 publish a phone** and **47,195 a usable
email**.

Québec is the province where English-language contractor directories are thinnest. In every other province a
contractor-marketing agency can start from HomeStars or a Yellow Pages scrape; in Québec most trades are not
there, but **every one of them must hold an RBQ licence**, and the RBQ publishes the whole register with the
contact details the contractor filed. This Actor turns that register into a lead list.

**Who uses it:** building-product distributors and manufacturer reps selling into Québec trades, construction
insurers and surety/bonding companies (bonding company, bond amount, licence restrictions), contractor-marketing
agencies, and anyone verifying that a Québec contractor is licensed for the work it is quoting.

### Why one row per licence matters

The RBQ file is **not** one row per contractor. It has one row for every combination of **licence ×
sub-category × trade name** — 927,338 rows for 54,225 licences, about **17 rows per contractor** (one excavation
firm is 140 rows). A scraper that emits file rows bills you 17 times for the same phone number.

This Actor folds each licence into **one row**, with its sub-categories and trade names as arrays, and it
**checks the fold on every licence** rather than assuming it:

- the number of distinct sub-categories equals the count the RBQ itself declares for that licence
  (`Nombre de sous-catégorie autorisées`) — 54,225 of 54,225 on 2026-09-22;
- the rows equal sub-categories × trade names, with no duplicate pair;
- every other column is identical across the licence's rows;
- no licence number ever reappears later in the file (a split licence would be two billed rows).

A licence that breaks any of these is **not delivered** and is listed in the run summary; more than 1% breaking
them fails the run loudly instead of shipping a quietly wrong list.

### Quick start

Plumbers (sub-category 15.5) in the Montréal region, 50 licences:

```json
{ "subcategories": ["15.5"], "regions": ["06"], "maxItems": 50 }
```

New contractor businesses licensed since 1 January 2026 anywhere in Québec, with a phone:

```json
{ "issuedOnOrAfter": "2026-01-01", "requirePhone": true, "maxItems": 2000 }
```

Roofers and siding contractors (sub-category 7) in Laval and Longueuil, with the named respondents:

```json
{ "subcategories": ["7"], "municipalities": ["Laval", "Longueuil"], "includeRegisterDetail": true, "maxItems": 500 }
```

### Example output

A real row from a live run on 2026-09-23 (build 0.1.4), unedited:

```json
{
  "licenceNumber": "1163-2767-87",
  "businessName": "B.R. électrique inc.",
  "otherNames": ["B.R. électrique Inc.", "BR Énergie", "BR Électrique"],
  "phone": "+14502630919",
  "phoneFormatted": "450-263-0919",
  "email": "info@brelectrique.ca",
  "emails": ["info@brelectrique.ca"],
  "emailRaw": "info@brelectrique.ca",
  "address": "1122 RUE DU SUD BUREAU 500 COWANSVILLE QC CANADA J2K 2Y3",
  "municipality": "Cowansville",
  "postalCode": "J2K 2Y3",
  "province": "QC",
  "country": "CA",
  "regionCode": "05",
  "region": "Estrie",
  "neq": "1173814741",
  "legalStatus": "Personne morale",
  "licenceType": "Entrepreneur",
  "licenceStatus": "Active",
  "issuingBody": "CMEQ",
  "categories": ["general", "specialised"],
  "isGeneralContractor": true,
  "isSpecialtyContractor": true,
  "subcategoryCodes": ["1.3", "16"],
  "subcategories": [
    { "code": "1.3", "label": "Bâtiments de tout genre", "category": "general" },
    { "code": "16", "label": "Électricité", "category": "specialised" }
  ],
  "managementQualifications": [
    { "code": "ADM", "label": "Administration d'entreprise de construction" },
    { "code": "GPC", "label": "Gestion de projets et de chantiers de construction" },
    { "code": "SEC", "label": "Gestion de la sécurité sur les chantiers de construction" }
  ],
  "subcategoryCountDeclared": 5,
  "issueDate": "1984-03-13",
  "annualPaymentDueDate": "2027-04-17",
  "hasRestriction": false,
  "restrictionStartDate": null,
  "restrictionEndDate": null,
  "bondingCompany": "L'Unique assurances générales",
  "bondAmountCad": 40000,
  "identityWithheldBySource": false,
  "sourceRowCount": 15,
  "sourceSnapshotDate": "2026-09-18",
  "source": "Régie du bâtiment du Québec — Liste des licences actives (Données Québec, CC-BY 4.0)"
}
```

### Fields

| Field | What it is |
|---|---|
| `licenceNumber` | RBQ licence number, `NNNN-NNNN-NN`. The row key. |
| `businessName` | Name of the licence holder as registered. |
| `otherNames` | Every trade name (autre nom) registered on the licence. |
| `phone` / `phoneFormatted` | The registered phone, as `+1XXXXXXXXXX` and `XXX-XXX-XXXX`. Reformatted only. |
| `email` / `emails` / `emailRaw` | The registered email. `emailRaw` is the cell exactly as published; `email` is set only when the whole cell is one valid address (or `emails` when it is a `;`-separated list). |
| `address`, `municipality`, `postalCode`, `province`, `country` | The published address verbatim; postal code, province and country are the tokens already in it, never looked up. |
| `regionCode`, `region` | Québec administrative region (01–17). |
| `neq` | Québec enterprise number (Registraire des entreprises) — the join key to the business register. |
| `legalStatus` | `Personne morale`, `Personne physique`, `Corporation` or `Autorite publique`. |
| `licenceType` | `Entrepreneur` or `Constructeur-proprietaire` (owner-builder). |
| `licenceStatus` | Always `Active` — the file is the active register. |
| `issuingBody` | `Regie` (RBQ), `CMEQ` (master electricians' corporation) or `CMMTQ` (master pipe-mechanics' corporation), which issue licences for their trades on the RBQ's behalf. |
| `categories`, `isGeneralContractor`, `isSpecialtyContractor` | Whether the licence holds general (1.x) and/or specialty (2–17) sub-categories. |
| `subcategoryCodes`, `subcategories[]` | Every trade sub-category, with the RBQ's own French label. |
| `managementQualifications[]` | The management qualifications held through the licence's respondent (ADM, GPC, SEC, and the owner-builder variants). |
| `subcategoryCountDeclared` | The RBQ's own count, kept so you can check the fold yourself. |
| `issueDate`, `annualPaymentDueDate` | Date the licence was first issued; next annual fee date. |
| `hasRestriction`, `restrictionStartDate`, `restrictionEndDate` | Licence restriction (45 licences on 2026-09-22), e.g. a ban on public contracts. |
| `bondingCompany`, `bondAmountCad` | Who bonds the contractor, and the bond amount (CAD 20,000 or 40,000 — the only two values in the file). |
| `identityWithheldBySource` | `true` when the RBQ publishes no name, address, phone or email for the licence. |
| `sourceRowCount`, `sourceSnapshotDate`, `source` | How many file rows folded into this one; the date of the RBQ extract. |

With **`includeRegisterDetail: true`** each row also gets, from the RBQ's own register:

| Field | What it is | Seen on (40 licences, live run 2026-09-23) |
|---|---|---|
| `respondents[]` | `firstName`, `lastName`, `isDirector`, `qualifications` of each person answering for the licence | 40 / 40 |
| `directors[]` | Names of the respondents the register flags as directors | 29 / 40 |
| `phoneExtension` | Extension for the registered phone | 13 / 40 |
| `guaranteePlanAccreditation` | New-home guarantee-plan accreditation number | 4 / 40 |
| `workLocations[]` | Additional registered work locations | 1 / 40 |
| `restrictionText` | The restriction in the RBQ's words (e.g. *"cette licence comporte une restriction qui interdit de soumissionner pour un contrat public…"*) | 12 / 12 restricted licences probed |
| `registerDetailStatus` | `ok`, `not-found` or `unreachable` | |

### Field fill — measured on the whole register

Counted over all **54,225** licences in the 2026-09-22 file (live platform run, full read, CRC-verified):

| Field | Licences | % of register | % of named licences (49,770) |
|---|---:|---:|---:|
| `businessName` | 49,770 | 91.8% | 100% |
| `phone` | 49,764 | 91.8% | 99.99% |
| `email` (valid) | 47,195 | 87.0% | 94.8% |
| `address` | 49,764 | 91.8% | 99.99% |
| `postalCode` | 49,757 | 91.8% | |
| `neq` | 53,312 | 98.3% | |
| `bondingCompany` / `bondAmountCad` | 53,189 | 98.1% | |
| `regionCode` | 53,121 | 98.0% | |
| `municipality` | 54,203 | 99.96% | |
| `issueDate` | 54,225 | 100% | |

The whole gap in phone, email and address is one thing: **the RBQ withholds the identity of individual licence
holders** (`Personne physique`). All 4,455 of them have no name, no address, no phone and no email in the file.
Those licences are **skipped and not charged** by default; set `includeWithheldIdentities: true` if you want
them anyway (for example to count sole proprietors per trade) — they are then billed like any other row.

33 email cells are free text rather than an address (`"x@y.com/ M. Marco Perron"`, `"a@b@.com"`). For those,
`email` is `null` and the cell is kept verbatim in `emailRaw` — the Actor never guesses which part was meant.

Every value was checked for placeholders, not just for being present: all phones are 10-digit North-American
numbers, all NEQs are 10 digits, all bond amounts are 20,000 or 40,000, and no value repeats as a filler.

### Inputs

| Input | Default | What it does |
|---|---|---|
| `subcategories` | all | RBQ sub-category codes; dotted-prefix match (`"15"` = 15.1–15.10, `"1.1"` = 1.1.1 and 1.1.2, never 1.10). |
| `regions` | all | Administrative region codes 01–17. |
| `municipalities` | all | Municipality names; accents, case and hyphens ignored. |
| `contractorCategories` | both | `general` and/or `specialised`. |
| `legalStatuses` | all | Legal form. |
| `licenceTypes` | both | `Entrepreneur` and/or `Constructeur-proprietaire`. |
| `keyword` | — | Business name or trade name contains. |
| `issuedOnOrAfter` | — | `YYYY-MM-DD`: licences first issued on or after this date — new businesses. |
| `requirePhone` / `requireEmail` | off | Only licences with a phone / a valid email. |
| `includeWithheldIdentities` | off | Also deliver (and bill) licences the RBQ publishes without identity. |
| `includeRegisterDetail` | off | Add named respondents, directors, restriction text and more from the RBQ register (one extra request per licence). |
| `onlyNewSinceLastRun` + `stateKey` | off | Monitoring mode: only licences that were not in the register at your previous run. The first run saves a baseline. |
| `maxItems` | 50 | Stop after this many licences. |
| `proxyConfiguration` | no proxy (direct) | See *Reliability* below. |

**Common sub-category codes:** 1.1.1 / 1.1.2 new homes under a guarantee plan · 1.2 small buildings · 1.3
buildings of any kind · 1.4 roads and piping · 2.5 excavation · 3.2 small concrete work · 4.2 masonry, marble,
ceramic · 5.2 metal work · 6.2 wood and plastic · 7 insulation, waterproofing, roofing, cladding · 8 doors and
windows · 9 finishing · 10 solid-fuel heating · 13.x fire protection · 14.x elevators · 15.1–15.10 heating,
gas, plumbing (15.5), ventilation, refrigeration · 16 electrical · 17.x instrumentation and security systems.
Every row carries the official label, so you never need this list to read the output.

### Pricing

**$0.0054 per licence delivered** — $5.40 per 1,000. No start fee, and you are **not** charged for licences
your filters remove or for withheld-identity licences (unless you opt in). The default run (`maxItems` 50) costs
at most **$0.27**. The entire register of named contractors (about 49,770) is about **$269**.

The other RBQ actor on the Store charges $0.006 per record **plus** a start fee ($0.005 per GB of memory, $0.02
at its 4 GB default) **plus** the platform usage of the run, which its pricing passes to you.

### How it compares

|  | This Actor | truenorthdata/canada-contractor-licenses |
|---|---|---|
| Source | RBQ open data (same file) | RBQ open data |
| Price | $0.0054 / licence, nothing else | $0.006 / record + start fee + platform usage |
| Phone, email, NEQ, address, trade names | ✓ | ✓ |
| Sub-category codes | ✓ with official labels | ✓ |
| Bond amount | ✓ | ✓ |
| **Bonding company** | ✓ | — |
| **Legal status, licence type, issuing body (CMEQ / CMMTQ)** | ✓ | — |
| **Issue date, annual fee date, restriction dates** | ✓ | "restrictions" named in its README, not in its schema |
| **Named respondents and directors, restriction text** | ✓ (optional) | — |
| Filters | sub-category, region, municipality, category, legal status, licence type, name, issue date, phone/email required | keyword, class, region |
| New-since-last-run monitoring | ✓ | ✓ |
| **Withheld-identity licences not billed by default** | ✓ | — |
| **Download proven whole (byte count + CRC-32 + 50,000-licence floor)** | ✓ | not stated |
| Ontario HCRA builders | — (Ontario is a separate Actor) | ✓ |

Compared from that Actor's own README and output schema (build 0.2.8), 2026-09-22.

### Reliability

The register is a single 11.4 MB zip that the RBQ republishes on Données Québec every day. Large bodies are
known to be cut short on datacenter proxy exits **while still reporting HTTP 200**, which would silently turn
the register into a smaller one. So this Actor:

1. reads the zip as a sequence of **byte-range pieces** (256 KB, 512 KB, 1 MB, then 2 MB), checks every piece
   against its `Content-Range`, and re-fetches a short piece on a fresh proxy session;
2. inflates and parses **as the bytes arrive**, so a 50-licence run stops after well under 1 MB and never pays
   for the other 10 MB;
3. on a full read, proves the file whole three ways — total bytes, the zip's **CRC-32** and inflated size, and a
   floor of **50,000 licences** — and fails the run rather than ship a short register;
4. uses `If-Range` with the file's ETag, so if the RBQ replaces the file mid-run the Actor stops cleanly instead
   of splicing two days together.

The default transport is **direct (no proxy)**: the file is open data on a public government portal, and every
piece is length-checked regardless of route. Measured 2026-09-22/23: direct whole-file reads from Apify's servers
all complete and CRC-verified; through Apify RESIDENTIAL 8 / 8 complete and CRC-verified (3 on the platform, 5
from outside), 0 short pieces. Pick RESIDENTIAL in the proxy field if a direct read ever fails for you; if the
proxy cannot be started, the run falls back to direct instead of failing. One
residential piece once stalled without ever timing out, so every piece now has its own hard deadline (18 s for
256 KB up to 39 s for 2 MB) and is aborted and re-fetched on a new exit when it passes it. Seven 50-licence runs
took 4 to 23 seconds; reading the whole register takes 100 to 145 seconds at the default 1 GB of memory.

### Data limits

- **Active licences only.** The open-data file is the active register; suspended, cancelled or expired
  licences are not in it.
- **No websites.** The RBQ does not publish one.
- **Individuals are anonymous.** The RBQ withholds the identity of every individual licence holder (4,455); see
  above.
- **Extract date.** Each row carries `sourceSnapshotDate`, the date the RBQ produced the extract inside the zip
  (2026-09-18 in the file published 2026-09-22). The RBQ's live register may be a few days ahead of it.
- **Bond claims, orders and licence events** are exposed by the register API but were empty on all 172 licences
  probed, including 12 under restriction, so they are not shipped as a column of zeros.
- The register detail adds one request per licence (about 0.4 s, 8 in parallel); use it on filtered runs.

### Source

- **Data:** *Liste des licences actives de la Régie du bâtiment du Québec*, published by the Régie du bâtiment
  du Québec on [Données Québec](https://www.donneesquebec.ca/recherche/dataset/licencesactives) under
  **Creative Commons Attribution 4.0 (CC-BY 4.0)**, refreshed daily. A full read is 8 ranged requests; a
  50-licence run usually 1–2.
- **Register detail** comes from the RBQ's public licence register (`pes.rbq.gouv.qc.ca`), the same data its
  search page shows.

### Run summary

Every run writes `RUN_SUMMARY` to its key-value store: bytes read vs the file's size, pieces retried, CRC and
size checks, licences seen and matched, withheld identities skipped, any licence that failed an invariant, and
per-field fill for both the rows delivered and every licence the run read.

# Actor input Schema

## `subcategories` (type: `array`):

RBQ licence sub-category codes, e.g. 15.5 (plumbing), 16 (electrical), 7 (insulation, waterproofing, roofing and cladding), 1.2 (small buildings), 1.3 (buildings of any kind), 2.5 (excavation). Dotted-prefix match: "15" matches 15.1 to 15.10, "1.1" matches 1.1.1 and 1.1.2. A licence matches if it holds ANY listed code. Empty = all trades.

## `regions` (type: `array`):

Québec administrative regions (by the RBQ region code). Empty = all of Québec.

## `municipalities` (type: `array`):

Municipality names, e.g. Montréal, Laval, Québec, Gatineau. Accents, case and hyphens are ignored ("Levis" matches "Lévis"). Empty = all.

## `contractorCategories` (type: `array`):

general = holds at least one general-contractor sub-category (1.x); specialised = holds at least one specialty sub-category (2 to 17). Empty = both.

## `legalStatuses` (type: `array`):

The holder's legal form as the register states it. Empty = all.

## `licenceTypes` (type: `array`):

Entrepreneur = contractor working for others (98% of licences). Constructeur-propriétaire = owner-builder working on its own property (often municipalities and developers). Empty = both.

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

Keep only licences whose business name or a trade name contains this text (accents and case ignored), e.g. toiture, plomberie, excavation.

## `issuedOnOrAfter` (type: `string`):

YYYY-MM-DD. Only licences first issued on or after this date: new contractor businesses. Empty = any date.

## `requirePhone` (type: `boolean`):

Skip licences the register publishes without a phone number.

## `requireEmail` (type: `boolean`):

Skip licences without a usable email address.

## `includeWithheldIdentities` (type: `boolean`):

The RBQ withholds the name, address, phone and email of every individual (Personne physique) licence holder, about 4,400 licences. They are skipped and NOT charged by default; turn this on to receive them anyway (licence number, NEQ when present, sub-categories, region, bond). Each is then a billed row.

## `includeRegisterDetail` (type: `boolean`):

For each delivered licence, also call the RBQ's own register to add the named respondents (first and last name, director flag, qualifications), work locations, the restriction text (e.g. a ban on public contracts) and phone extension. Home addresses of respondents are never returned. One extra request per licence (about 0.4 s, 8 in parallel).

## `onlyNewSinceLastRun` (type: `boolean`):

Monitoring mode: return only licences that were not in the register the last time this ran with the same state key. The first run saves a baseline and returns rows as usual. Always reads the full register.

## `stateKey` (type: `string`):

Name for the saved licence list used by monitoring mode, so several monitors can run side by side.

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

Stop after this many licences (you are charged per licence delivered). The whole register is about 54,000 licences; about 49,700 publish a phone.

## `proxyConfiguration` (type: `object`):

Defaults to NO PROXY (direct). The register is open data on a public government portal, and this Actor reads it as byte-range pieces, checks each against its Content-Range, retries a short piece, and proves a full read with the zip's own CRC-32, so a direct download is safe and costs no proxy transfer. Choose Apify RESIDENTIAL if a direct read ever fails for you (measured 8/8 clean whole reads). If the proxy cannot be started, the run falls back to direct.

## Actor input object example

```json
{
  "subcategories": [
    "15.5"
  ],
  "regions": [
    "06"
  ],
  "requirePhone": false,
  "requireEmail": false,
  "includeWithheldIdentities": false,
  "includeRegisterDetail": false,
  "onlyNewSinceLastRun": false,
  "stateKey": "default",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per RBQ licence: business name, phone, email, address, NEQ, sub-categories, bonding company and bond amount.

## `summary` (type: `string`):

Download integrity (bytes, CRC-32, resumes), licence counts and per-field fill for the run.

# 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 = {
    "subcategories": [
        "15.5"
    ],
    "regions": [
        "06"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/rbq-quebec-licence-register-scraper").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 = {
    "subcategories": ["15.5"],
    "regions": ["06"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/rbq-quebec-licence-register-scraper").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 '{
  "subcategories": [
    "15.5"
  ],
  "regions": [
    "06"
  ],
  "maxItems": 50
}' |
apify call scrapersdelight/rbq-quebec-licence-register-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/rbq-quebec-licence-register-scraper"
        }
    }
}
```

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/9XD0kdrBde77fsa0T/builds/fvCZFq10FcpfCEvDs/openapi.json