# CILEX Practitioner Register Scraper (`crawlerbros/cilex-practitioner-register-scraper`) Actor

Scrape the CILEX Authorised Practitioners Directory - CILEx Regulation's official public register of Chartered Legal Executives and CILEX Practitioners authorised for reserved legal activities in England & Wales. Search by name, employer/firm, postcode, or practising right.

- **URL**: https://apify.com/crawlerbros/cilex-practitioner-register-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## CILEX Practitioner Register Scraper

Scrape the **CILEX Authorised Practitioners Directory** — CILEx Regulation's official public register of **Chartered Legal Executives (Fellows)** and **CILEX Practitioners** authorised to carry out reserved legal activities in **England & Wales**. Search by practitioner name, employer/firm name, postcode, city/town, and/or practising right/title. No login, no cookies, no paid proxy.

CILEx Regulation is the independent regulator for members of CILEX (the Chartered Institute of Legal Executives) who are authorised to provide legal services. This directory is the same authoritative source consumers and employers use to check someone's credentials before instructing them.

### What this actor does

- **Combinable search filters:** practitioner name, employer/firm name, postcode, employer city/town, and/or a specific practising right/title — mix and match, same as the official directory's own search form
- **34 practising rights/titles** available as a dropdown: Chartered Legal Executive (and its litigation/advocacy/conveyancing/immigration/probate specialisms), CILEX Practitioner variants, Associate Prosecutor, and more
- **Employer detail:** name, full address (with city/postcode broken out), and whether the employer is itself a CILEx Regulation-authorised entity
- **Practising rights history:** every practising right held, each with its authorisation date
- **Disciplinary-record flag:** whether a practitioner has a published disciplinary finding on file, per CILEx Regulation's Publication Policy
- **Empty fields are always omitted** — you never see `null`, `""`, or `[]`

### Output fields

| Field | Description |
|---|---|
| `id` | CILEx Regulation's internal contact identifier (GUID) |
| `name` | Full name, including salutation if published (e.g. `Mr Craig Arrowsmith`) |
| `title` | Salutation only, when recognisable (e.g. `Mr`, `Mrs`, `Dr`) |
| `employerName` | Current employer / firm name |
| `employerAddress` | Full employer address as a single string |
| `employerAddressLines[]` | Employer address broken into its individual lines |
| `employerCity` | Employer's town/city |
| `employerPostcode` | Employer's postcode |
| `employerAuthorised` | `true` if the employer is itself an entity authorised and regulated by CILEx Regulation |
| `practicingRights[]` | Every practising right held: `{ title, authorisationDate }` |
| `practicingRightTitles[]` | Just the title strings, for quick filtering/display |
| `hasDisciplinaryRecord` | `true` if a disciplinary finding is published against this practitioner |
| `sourceUrl` | The directory search-results URL this record was scraped from. This is an encrypted, single-use link generated for that specific run — it may no longer resolve if revisited later. Re-run the same search filters on the directory's own site (or this actor) to get a fresh, working link. |
| `recordType` | Always `practitioner` |
| `scrapedAt` | UTC ISO timestamp of when the record was scraped |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `contactName` | string | `Smith` | Full or partial practitioner name (case-insensitive substring match) |
| `firmName` | string | – | Full or partial employer/firm name |
| `postcode` | string | – | Employer postcode or partial postcode (substring match, e.g. `M2`) |
| `addressCity` | string | – | Employer city/town or partial city/town (substring match, e.g. `Manchester`) |
| `practicingRight` | select | – | Restrict to one of the 34 known practising rights/titles |
| `disciplinaryOnly` | boolean | `false` | Only emit practitioners with a published disciplinary finding |
| `employerAuthorisedOnly` | boolean | `false` | Only emit practitioners whose employer is itself CILEx-authorised |
| `nameContains` | string | – | Extra client-side substring filter on `name` |
| `maxItems` | integer | `30` | Hard cap on emitted records (1–300) |

At least one of `contactName`, `firmName`, `postcode`, `addressCity`, or `practicingRight` must be provided — this mirrors the official directory, which requires at least one search term.

#### Example: search by surname

```json
{
  "contactName": "Smith",
  "maxItems": 30
}
```

#### Example: search by employer + practising right

```json
{
  "firmName": "Brabners",
  "practicingRight": "ce1cd209-6372-e911-a988-00224800c719",
  "maxItems": 20
}
```

#### Example: browse practitioners near a postcode, disciplinary records only

```json
{
  "postcode": "M2",
  "disciplinaryOnly": true,
  "maxItems": 50
}
```

#### Example: browse all practitioners in a city

```json
{
  "addressCity": "Manchester",
  "maxItems": 100
}
```

### Use cases

- **KYC / due diligence** — verify a legal executive holds a current, genuine CILEX practising right before instructing or onboarding them
- **Compliance monitoring** — check for published disciplinary findings against a named individual
- **Recruitment** — find practitioners with a specific specialism (conveyancing, probate, immigration, litigation) in a given area
- **Market research** — map which firms employ CILEX-authorised practitioners in a region

### FAQ

**Where does this data come from?** [CILEx Regulation's public Authorised Practitioners Directory](https://cilexregulation.org.uk/practitioners-directory/), the independent regulator's own register of Chartered Legal Executives and CILEX Practitioners.

**Why do I need to provide a search term?** The directory holds a very large number of records; searching with no criteria at all isn't supported by the source system itself. Providing at least a partial name, firm name, or postcode keeps searches fast and reliable — exactly as the source's own search form requires.

**Very broad single-letter searches are slow or fail — why?** A one- or two-character name/firm search can match thousands of records, and the source's own results page can take a long time to render (or time out) for such broad queries — this reflects the live site's own behaviour, not a limitation of the actor. Use a fuller name, firm name, or postcode for reliable results.

**Not every practitioner has disciplinary or employer-authorisation data — why are those fields sometimes missing?** Those fields are only included when the source page actually publishes them for that practitioner; this actor never fills them with placeholder values.

**Is there a limit on how many results I can get?** Yes — `maxItems` caps the run at up to 300 records per search. Narrow your search terms (add a firm name or postcode alongside the name) to get a more targeted, faster result set.

**Can I open the `sourceUrl` link later to double-check a record?** The link works right after the run, but the directory issues it as an encrypted, single-use link tied to that specific search — it can stop resolving if you revisit it much later. To re-verify a practitioner, re-run the same search (by name, firm, postcode, or city) rather than bookmarking `sourceUrl` long-term.

**Why isn't there a "membership number" or "area of law" search field?** The directory's search backend is shared across several CILEx Regulation registers (practitioners, ABS firms, accountancy firms), and its front-end explicitly disables `Membership Number`, `Area of Law`, `Authorised Areas of Practice`, `Name of Lawyer`, and `ABS firm` filters for the Practitioner directory specifically — they exist in the shared code for other CILEx registers, not this one. We could not confirm these fields are populated for practitioner records, so they're left out rather than shipping an unverified filter.

# Actor input Schema

## `contactName` (type: `string`):

Full or partial name of the Chartered Legal Executive / CILEX Practitioner, e.g. `Smith` or `Craig Arrowsmith`. Case-insensitive substring match.

## `firmName` (type: `string`):

Full or partial employer/firm name, e.g. `Brabners`. Case-insensitive substring match.

## `postcode` (type: `string`):

UK postcode or partial postcode of the employer's address, e.g. `M2` or `M2 4LQ`. Matches anywhere in the postcode (substring match), not just as a prefix.

## `addressCity` (type: `string`):

Full or partial employer address city/town, e.g. `Manchester` or `Leeds`. Case-insensitive substring match — combine with `postcode` for a narrower search, or use on its own to browse all practitioners in a city.

## `practicingRight` (type: `string`):

Restrict results to practitioners holding this specific CILEx Regulation practising right / professional title. Combine with `contactName`, `firmName`, or `postcode` for best performance.

## `disciplinaryOnly` (type: `boolean`):

When true, only emit practitioners with a published disciplinary finding on file.

## `employerAuthorisedOnly` (type: `boolean`):

When true, only emit practitioners whose employer is itself an entity authorised and regulated by CILEx Regulation.

## `nameContains` (type: `string`):

Extra client-side, case-insensitive substring filter applied to the practitioner's name — useful when combining a broad `firmName`/`postcode` search with a narrower name check.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "contactName": "Smith",
  "disciplinaryOnly": false,
  "employerAuthorisedOnly": false,
  "maxItems": 20
}
```

# Actor output Schema

## `practitioners` (type: `string`):

Dataset containing all scraped CILEX practitioner 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 = {
    "contactName": "Smith",
    "disciplinaryOnly": false,
    "employerAuthorisedOnly": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/cilex-practitioner-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 = {
    "contactName": "Smith",
    "disciplinaryOnly": False,
    "employerAuthorisedOnly": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/cilex-practitioner-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 '{
  "contactName": "Smith",
  "disciplinaryOnly": false,
  "employerAuthorisedOnly": false,
  "maxItems": 20
}' |
apify call crawlerbros/cilex-practitioner-register-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/cilex-practitioner-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/RhiwGJ0d9jv626ryI/builds/yFdLHQcC4BAjNDqTN/openapi.json