# Commonwealth Corporate Registry MCP (`ryanclinton/commonwealth-corporate-registry-mcp`) Actor

Multi-jurisdiction corporate registry intelligence for AI agents via the Model Context Protocol.

- **URL**: https://apify.com/ryanclinton/commonwealth-corporate-registry-mcp.md
- **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community)
- **Categories:** AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Commonwealth Corporate Registry MCP

Commonwealth corporate registry intelligence for AI agents, delivered via the Model Context Protocol. This MCP server queries Australian ABN, Canadian Corporation, New Zealand Companies Office, UK Companies House, OpenCorporates, GLEIF LEI, and Wikipedia simultaneously — returning cross-jurisdiction entity data, concordance scores, and identity verification grades in a single structured response.

Built for KYB analysts, compliance teams, and AI agents that need authoritative company registration data across Australia, Canada, New Zealand, and the UK without manually searching four separate government portals. Seven Apify actors run in parallel behind 8 MCP tools, with a 5-minute in-memory cache that prevents duplicate registry calls within the same session.

### What data can you access?

| Data Point | Source | Example |
|-----------|--------|---------|
| 📋 ABN, entity name, GST status | Australia ABN Lookup | ABN 83 914 571 673 — Active |
| 🏢 Corporation number, incorporation date | Canada Corporation Search | 1234567-8 — Active Federal |
| 🔢 NZBN, company type, director details | NZ Companies Office | 9429041248743 — Registered |
| 🏛️ Company number, filing status, PSC data | UK Companies House | 09248896 — Active |
| 🌐 140+ jurisdiction coverage, OpenCorp ID | OpenCorporates | gb/09248896 — Active |
| 🔑 20-character LEI code, registration status | GLEIF LEI | 2138005O9XJIJN4JPN90 — Active |
| 📖 Encyclopedic history and operations | Wikipedia | BHP Group — 6M+ article index |
| 📊 Concordance score 0–1 across registries | Cross-reference engine | 0.87 — High match confidence |
| 🎓 Identity verification grade A–F | Scoring engine | Grade A — LEI verified |
| 🗺️ Jurisdiction presence score 0–1 | Presence scoring | 0.80 — 4 jurisdictions |

### ⬇️ MCP Tools

| Tool | Price | Description |
|------|-------|-------------|
| `map_commonwealth_entities` | $0.05 | Map corporate entities across Commonwealth registries with jurisdiction breakdown, network graph, and per-entity presence scores. |
| `search_australian_business` | $0.05 | Search the Australian ABN registry for entity name, ABN, entity type, GST registration, and status. |
| `search_canadian_corporation` | $0.05 | Search the Canadian federal corporation registry for corporation name, number, directors, and incorporation status. |
| `search_nz_company` | $0.05 | Search NZ Companies Office for company name, NZBN, company type, directors, and registration status. |
| `search_uk_company` | $0.05 | Search UK Companies House for company number, filing status, officers, and persons with significant control. |
| `cross_reference_registries` | $0.05 | Cross-reference entity across all Commonwealth registries and LEI with concordance scoring and match confidence 0–1. |
| `verify_global_identity` | $0.05 | Verify corporate identity with name variation detection, LEI verification, Wikipedia corroboration, and A–F confidence grading. |
| `generate_registry_report` | $0.05 | Comprehensive multi-jurisdiction registry report: findings ranked by severity, LEI coverage analysis, status concordance, and actionable recommendations. |

### Why use Commonwealth Corporate Registry MCP?

Verifying a company across Australia, Canada, New Zealand, and the UK means opening four government portals, running four separate searches, and manually reconciling the results. For a compliance analyst, that is 30–60 minutes of work per entity — before any analysis begins. For an AI agent, it means four sequential tool calls returning raw, unstructured data that requires further interpretation.

This MCP server orchestrates all seven registry data sources in parallel, builds a unified entity graph, and returns scored, structured intelligence from a single tool call.

- **AI-native** — MCP protocol support for Claude Desktop, Cursor, Windsurf, Cline, and any MCP-compatible agent framework
- **Parallel execution** — all registry actors run concurrently; `Promise.all` dispatch means no sequential bottleneck
- **Session caching** — 5-minute in-memory cache keyed by `source:query` prevents redundant registry calls in multi-tool workflows
- **Scored output** — concordance scores, presence scores, and A–F identity grades are computed server-side, not raw registry dumps
- **Spending controls** — per-event charging with configurable spending limits via Apify's platform; the server halts cleanly when budget is reached
- **Scheduling and webhooks** — run on a schedule or trigger via webhook for continuous monitoring workflows

### Features

- **7-actor parallel dispatch** — sends queries to Australia ABN, Canada Corporation, NZ Companies, UK Companies House, OpenCorporates, GLEIF LEI, and Wikipedia simultaneously using `Promise.all`
- **Unified registry graph** — `buildRegistryNetwork` constructs a typed node/edge graph with four node types (`company`, `registration`, `lei_entity`, `article`) and seven edge types tracking jurisdiction relationships
- **Concordance scoring** — `crossReferenceRegistries` calculates a 0–1 concordance score based on registration status agreement across jurisdictions: `(activeCount / totalStatuses) * 0.3 + jurisdictionCount * 0.2 + LEI bonus 0.3`
- **Match confidence formula** — overall `matchConfidence` is bounded at 1.0: `min(1, jurisdictions * 0.2 + leiCoverage * 0.3 + concordanceScore * 0.3)`
- **Presence scoring** — `scoreMultiJurisdictionPresence` evaluates each entity: `min(1, jurisdictionCount * 0.2 + hasLEI * 0.2)`, returning up to 40 entities sorted by score
- **Identity confidence grading** — `verifyGlobalIdentity` builds confidence from four components: registration score (max 0.4 at 4+ registrations), LEI score (0.25), Wikipedia corroboration (0.15), name consistency (0.05–0.20); maps to grades A (≥0.8), B (≥0.6), C (≥0.4), D (≥0.2), F (<0.2)
- **Name variation detection** — collects `entityName`, `corporationName`, `companyName`, `legalName` from all registry records and LEI, normalizes to lowercase for comparison, surfaces up to 10 variations per entity
- **Report severity ranking** — `generateRegistryReport` produces findings categorized as `critical`, `high`, `medium`, or `low`, sorted by severity with actionable remediation steps
- **LEI coverage analysis** — calculates LEI coverage rate across all entities; flags `critical` when rate < 20%, `high` when < 50%
- **Status discordance detection** — identifies entities where registration statuses differ across jurisdictions (e.g., Active in UK but Dissolved in Australia), flags as `critical`
- **OpenCorporates breadth** — includes 140+ jurisdictions beyond the core four Commonwealth registries via OpenCorporates, extending coverage to offshore and non-Commonwealth registrations
- **Dual transport support** — serves both SSE (`/sse` + `/messages`) and Streamable HTTP (`/mcp`) MCP transports; SSE sessions are stored per `sessionId` for stateful connections
- **Result pagination** — all tools cap results at 40 entities and 500 dataset items per actor to maintain response time and cost predictability

### Use cases for Commonwealth corporate registry intelligence

#### KYB entity verification for financial services

Compliance teams onboarding new business clients need to verify entity existence, registration status, and legal name across the jurisdictions the client claims to operate in. `verify_global_identity` returns a single A–F grade derived from registry registrations, LEI status, and name consistency — giving onboarding teams a clear accept/review/reject signal without manual portal searches.

#### Cross-border corporate structure mapping

M&A advisors and investment analysts need to understand how a target company is structured across Commonwealth jurisdictions before due diligence begins. `map_commonwealth_entities` returns a jurisdiction breakdown showing where registrations exist, how many entities are linked, and their presence scores — revealing subsidiary structures, dormant shells, and holding company arrangements.

#### AML and compliance registry checks

AML compliance programs require periodic entity re-verification against current registry status. `cross_reference_registries` surfaces status discordance — where a company shows Active in one jurisdiction but Struck Off or Dissolved in another — which is a flag for further investigation in AML and PEP screening workflows.

#### M&A due diligence registry research

Deal teams generating Information Memoranda or conducting vendor due diligence need comprehensive registry summaries. `generate_registry_report` produces structured findings ranked by severity: LEI coverage gaps, status discordance, name variations, and multi-jurisdiction presence — structured output that feeds directly into due diligence reports.

#### AI agent corporate research workflows

AI agents conducting company research need structured registry data without browser automation. Each MCP tool returns clean JSON that agents can reason over, cite in research summaries, or pass to downstream tools — replacing ad-hoc web scraping with deterministic, scored registry intelligence.

#### Supplier and counterparty due diligence

Procurement and vendor management teams verifying supplier legitimacy before contract execution can use `verify_global_identity` to confirm the supplier exists in official registries, holds a valid LEI (important for financial transactions), and has consistent registration details across jurisdictions.

### How to connect this MCP server

#### Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "commonwealth-corporate-registry": {
      "url": "https://commonwealth-corporate-registry-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
````

#### Cursor / Windsurf / Cline

Add the MCP server URL in your editor's MCP settings panel:

```
https://commonwealth-corporate-registry-mcp.apify.actor/mcp
```

With the `Authorization: Bearer YOUR_APIFY_TOKEN` header configured in your client.

#### SSE transport (legacy clients)

```
https://commonwealth-corporate-registry-mcp.apify.actor/sse
```

#### Programmatic HTTP (cURL)

```bash
## Call verify_global_identity
curl -X POST "https://commonwealth-corporate-registry-mcp.apify.actor/mcp" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "verify_global_identity",
      "arguments": {
        "query": "BHP Group",
        "sources": ["australia", "uk", "lei", "wiki"]
      }
    },
    "id": 1
  }'
```

#### Python (via MCP client or direct HTTP)

```python
import httpx
import json

response = httpx.post(
    "https://commonwealth-corporate-registry-mcp.apify.actor/mcp",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer YOUR_APIFY_TOKEN",
    },
    json={
        "jsonrpc": "2.0",
        "method": "tools/call",
        "params": {
            "name": "cross_reference_registries",
            "arguments": {
                "query": "Rio Tinto",
                "sources": ["australia", "uk", "canada", "lei"]
            }
        },
        "id": 1
    }
)

result = response.json()
content = json.loads(result["result"]["content"][0]["text"])
print(f"Entities found: {content['totalEntities']}")
print(f"Multi-jurisdiction: {content['multiJurisdictionCount']}")
print(f"Avg concordance: {content['avgConcordance']}")
for match in content["matches"][:5]:
    print(f"  {match['entity']}: {match['jurisdictions']} — confidence {match['matchConfidence']}")
```

#### JavaScript / TypeScript

```javascript
const response = await fetch("https://commonwealth-corporate-registry-mcp.apify.actor/mcp", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer YOUR_APIFY_TOKEN",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "tools/call",
    params: {
      name: "generate_registry_report",
      arguments: {
        query: "Macquarie Group",
        sources: ["australia", "uk", "canada", "newZealand", "lei", "wiki"]
      }
    },
    id: 1
  })
});

const data = await response.json();
const report = JSON.parse(data.result.content[0].text);

console.log(`Coverage: ${report.overallCoverage}`);
console.log(`Entities analyzed: ${report.entitiesAnalyzed}`);
console.log(`LEI coverage rate: ${(report.leiCoverageRate * 100).toFixed(1)}%`);
for (const finding of report.findings) {
  console.log(`[${finding.importance.toUpperCase()}] ${finding.category}: ${finding.finding}`);
}
```

### ⬆️ Output examples

#### verify\_global\_identity response

```json
{
  "verifications": [
    {
      "entity": "BHP Group Limited",
      "registrationsFound": 4,
      "jurisdictions": ["australia", "uk", "newZealand", "canada"],
      "nameVariations": [
        "BHP Group Limited",
        "BHP GROUP LIMITED",
        "BHP Billiton Limited"
      ],
      "identityConfidence": 0.85,
      "leiVerified": true,
      "wikipediaCorroborated": true,
      "verificationGrade": "A"
    }
  ],
  "totalVerified": 3,
  "avgConfidence": 0.72,
  "gradeDistribution": { "A": 1, "B": 1, "C": 1 }
}
```

#### cross\_reference\_registries response

```json
{
  "matches": [
    {
      "entity": "Pinnacle Resources International",
      "jurisdictions": ["australia", "uk", "lei"],
      "registrationIds": {
        "australia": "51 004 458 390",
        "uk": "08342156",
        "lei": "213800WSGIIZCXF1P572"
      },
      "matchConfidence": 0.82,
      "leiCoverage": true,
      "concordanceScore": 0.875
    }
  ],
  "totalEntities": 12,
  "multiJurisdictionCount": 4,
  "avgConcordance": 0.7341,
  "leiCoverageRate": 0.4167
}
```

#### generate\_registry\_report response

```json
{
  "findings": [
    {
      "category": "Multi-Jurisdiction Presence",
      "finding": "Entities found across 4 jurisdictions: australia, uk, canada, newZealand",
      "importance": "high",
      "evidence": "18 registration records across 4 jurisdictions",
      "action": "Review cross-jurisdiction compliance and regulatory obligations"
    },
    {
      "category": "Status Discordance",
      "finding": "1 entity/entities with inconsistent registration statuses across jurisdictions",
      "importance": "critical",
      "evidence": "Crestview Holdings Pty Ltd: active, dissolved",
      "action": "Investigate status discrepancies - may indicate dissolved or suspended registrations"
    },
    {
      "category": "LEI Coverage Gap",
      "finding": "33.3% of entities have LEI identifiers",
      "importance": "high",
      "evidence": "2 of 6 entities have LEI codes",
      "action": "Obtain LEI codes for entities involved in financial transactions or regulatory reporting"
    }
  ],
  "overallCoverage": "partial",
  "entitiesAnalyzed": 6,
  "jurisdictionsCovered": 4,
  "leiCoverageRate": 0.3333,
  "recommendations": [
    "Improve LEI coverage for financial transaction and regulatory compliance",
    "Resolve registration status inconsistencies across jurisdictions",
    "Expand registry searches to additional Commonwealth jurisdictions"
  ]
}
```

### Output fields

#### verify\_global\_identity

| Field | Type | Description |
|-------|------|-------------|
| `verifications[].entity` | string | Normalized entity name, max 60 characters |
| `verifications[].registrationsFound` | number | Count of registry records found across all sources |
| `verifications[].jurisdictions` | string\[] | List of jurisdictions where registrations were found |
| `verifications[].nameVariations` | string\[] | Up to 10 name variants collected across registry records and LEI |
| `verifications[].identityConfidence` | number | Composite confidence score 0–1 (reg score + LEI 0.25 + wiki 0.15 + name consistency 0.05–0.20) |
| `verifications[].leiVerified` | boolean | Whether a GLEIF LEI record was found for this entity |
| `verifications[].wikipediaCorroborated` | boolean | Whether a Wikipedia article was matched to this entity |
| `verifications[].verificationGrade` | string | A (≥0.8), B (≥0.6), C (≥0.4), D (≥0.2), F (<0.2) |
| `totalVerified` | number | Total entities assessed |
| `avgConfidence` | number | Mean identity confidence across all entities |
| `gradeDistribution` | object | Count of entities per grade: `{ "A": 2, "B": 1, ... }` |

#### cross\_reference\_registries

| Field | Type | Description |
|-------|------|-------------|
| `matches[].entity` | string | Entity name, max 60 characters |
| `matches[].jurisdictions` | string\[] | Jurisdictions where the entity has registrations |
| `matches[].registrationIds` | object | Registration IDs keyed by jurisdiction: `{ "australia": "ABN", "uk": "compNum", "lei": "LEI code" }` |
| `matches[].matchConfidence` | number | Overall confidence 0–1: `min(1, jurisdictions*0.2 + leiCoverage*0.3 + concordance*0.3)` |
| `matches[].leiCoverage` | boolean | Whether a GLEIF LEI was found for this entity |
| `matches[].concordanceScore` | number | Status concordance 0–1: proportion of registrations showing active/registered/current status |
| `totalEntities` | number | Total matched entities |
| `multiJurisdictionCount` | number | Entities appearing in 2+ jurisdictions |
| `avgConcordance` | number | Mean concordance score across all matches |
| `leiCoverageRate` | number | Proportion of entities with LEI coverage |

#### generate\_registry\_report

| Field | Type | Description |
|-------|------|-------------|
| `findings[].category` | string | Finding category: Multi-Jurisdiction Presence, LEI Coverage Gap, Status Discordance, Name Variations, Public Profile, No Results |
| `findings[].finding` | string | Human-readable finding description |
| `findings[].importance` | string | Severity: `critical`, `high`, `medium`, or `low` |
| `findings[].evidence` | string | Supporting evidence from registry data |
| `findings[].action` | string | Recommended remediation or follow-up action |
| `overallCoverage` | string | `comprehensive` (3+ jurisdictions and ≥30% LEI), `partial` (1+ jurisdiction), or `limited` |
| `entitiesAnalyzed` | number | Number of company nodes analyzed |
| `jurisdictionsCovered` | number | Count of distinct jurisdictions with registrations |
| `leiCoverageRate` | number | Proportion of entities with GLEIF LEI identifiers |
| `recommendations` | string\[] | Actionable recommendations ordered by priority |

#### Country search tools (search\_australian\_business, search\_uk\_company, etc.)

| Field | Type | Description |
|-------|------|-------------|
| `results[].entity` | string | Entity or company name |
| `results[].registrationId` | string | ABN, corporation number, NZBN, or UK company number |
| `results[].status` | string | Registration status from source registry |
| `results[].jurisdiction` | string | Source jurisdiction: `australia`, `canada`, `newZealand`, or `uk` |
| `results[].details` | object | Full raw record from the source registry actor |
| `totalFound` | number | Number of results returned |
| `jurisdiction` | string | Jurisdiction searched |

### How much does it cost to query Commonwealth corporate registries?

Every tool call is priced at **$0.05 per call**. Compute costs are included. The **Apify Free plan** includes $5 of monthly credits — enough for **100 tool calls** with no credit card required.

| Scenario | Tool calls | Cost per call | Total cost |
|----------|-----------|---------------|------------|
| Single entity verify | 1 | $0.05 | $0.05 |
| 10-entity KYB batch | 10 | $0.05 | $0.50 |
| 50-entity compliance review | 50 | $0.05 | $2.50 |
| 200-entity portfolio check | 200 | $0.05 | $10.00 |
| 1,000-entity bulk verification | 1,000 | $0.05 | $50.00 |

You can set a **maximum spending limit** per run in Apify's platform settings. The server returns a clean error message when the budget is reached rather than failing silently.

For context, KYB platform subscriptions (Kyckr, Creditsafe, Bureau van Dijk) typically cost $500–2,000/month. With this MCP server, most compliance teams running 200–500 checks per month spend $10–25 with no subscription commitment.

### How Commonwealth Corporate Registry MCP works

#### Phase 1: Query dispatch and caching

When a tool is called with a `query` and `sources` array, the `resolveData` function dispatches parallel Apify actor calls using `Promise.all`. Each source has a cache key formatted as `source:query` (e.g., `au:BHP Group`). If a matching entry exists in the in-memory `CACHE` Map and is less than 5 minutes old (TTL = `5 * 60_000` ms), the cached result is returned immediately without a network call. This is important for multi-tool workflows where the same entity is queried by `cross_reference_registries` followed immediately by `generate_registry_report`.

Each actor call uses the `apify-client` SDK, setting `waitSecs: 180` and `memory: 256` MB. Results are fetched from the actor's default dataset with a limit of 500 items per source. Failed actor calls return an empty array rather than throwing, so a single unavailable source does not abort the entire query.

#### Phase 2: Registry network construction

The 7 data arrays are passed to `buildRegistryNetwork`, which constructs a typed graph of `RegistryNode` and `RegistryEdge` objects. Company nodes are created for each unique entity name or registration ID, using a normalized key (`name.toLowerCase().replace(/[^a-z0-9]/g, '_')`). Registration nodes are created per jurisdiction with jurisdiction-tagged edge types: `registered_in_au`, `registered_in_ca`, `registered_in_nz`, `registered_in_uk`. LEI records create `lei_entity` nodes linked by `identified_by` edges with weight 0.95. Wikipedia articles are linked to company nodes via fuzzy prefix matching (15-character prefix inclusion check) with `described_in` edges at weight 0.6. OpenCorporates records use `listed_on` edges at weight 0.7 to reflect that OpenCorporates aggregates rather than primary registration.

#### Phase 3: Analysis and scoring

Depending on which tool was called, one of four analysis functions runs over the network:

- `mapCommonwealthEntities` — counts edges per node, builds jurisdiction breakdown, returns top-40 entities by connection count
- `crossReferenceRegistries` — for each company node, collects linked registration nodes, extracts jurisdiction list and registration IDs, computes concordance from status agreement, calculates `matchConfidence` formula
- `verifyGlobalIdentity` — computes the four-component confidence score, normalizes name variants across all registry records, assigns A–F grade
- `generateRegistryReport` — runs five sequential finding detectors (multi-jurisdiction, LEI coverage, status discordance, name variations, Wikipedia), sorts by severity, produces `overallCoverage` assessment and recommendations array

#### Phase 4: MCP transport and response

The MCP server supports two transport protocols. The Streamable HTTP transport at `/mcp` creates a new `StreamableHTTPServerTransport` per request with `crypto.randomUUID()` session IDs — appropriate for stateless API calls. The SSE transport at `/sse` maintains persistent sessions in the `transports` Map, with cleanup on connection close. Both transports use the same `McpServer` instance constructed fresh per request by `getServer()`. Results are serialized as `JSON.stringify(..., null, 2)` and returned as `text` content blocks.

### Tips for best results

1. **Start with `verify_global_identity` for new entities.** The A–F grade gives an immediate signal on whether a company has verifiable, consistent presence across registries. Grade C or below warrants deeper investigation before onboarding.

2. **Use `sources` to control cost and speed.** The default source list covers 6 registries. For quick checks where you only need UK Companies House data, pass `["uk"]` to call just that actor. Each source included adds one underlying actor call.

3. **Chain `cross_reference_registries` after `map_commonwealth_entities` in the same session.** The 5-minute cache means the second call reuses actor results from the first, costing only the MCP tool fee without additional actor compute.

4. **Use `generate_registry_report` for structured due diligence outputs.** The findings array is pre-sorted by severity (`critical` first) and includes `action` fields — suitable for direct insertion into due diligence report templates or compliance case management systems.

5. **Search by registration number for exact matches.** Passing an ABN, UK company number, or NZBN directly returns a precise match and avoids name-ambiguity results. For example, `"09248896"` returns a single UK Companies House record rather than all companies with a similar name.

6. **LEI verification is the strongest identity signal.** An entity with a valid GLEIF LEI and matching legal name has been independently verified by a Local Operating Unit (LOU) accredited by GLEIF. If `leiVerified: true` appears in `verify_global_identity`, that entity meets the identity standard required for financial transactions under many regulatory frameworks.

7. **Flag `Status Discordance` findings immediately.** A company showing Active in one jurisdiction and Dissolved or Struck Off in another is a material finding in KYB, AML, and credit underwriting contexts. The `generate_registry_report` tool surfaces this as a `critical` finding with specific entity names and status values in the evidence field.

### Combine with other MCP servers

| MCP Server | How to combine |
|-----------|---------------|
| [counterparty-due-diligence-mcp](https://apify.com/ryanclinton/counterparty-due-diligence-mcp) | Run registry verification first, then pass entities to counterparty due diligence for sanctions, PEP, and adverse media screening |
| [adversarial-corporate-opacity-mcp](https://apify.com/ryanclinton/adversarial-corporate-opacity-mcp) | Follow registry mapping with shell company detection and opacity scoring on identified multi-jurisdiction structures |
| [corporate-deep-research-mcp](https://apify.com/ryanclinton/corporate-deep-research-mcp) | Supplement registry status data with financial health, governance, and competitive intelligence |
| [opencorporates-search](https://apify.com/ryanclinton/opencorporates-search) | Use directly for deep dives into a single OpenCorporates jurisdiction beyond the MCP's bundled query |
| [gleif-lei-lookup](https://apify.com/ryanclinton/gleif-lei-lookup) | Access full GLEIF LEI data including corporate parent/child hierarchy and renewal history |
| [uk-companies-house](https://apify.com/ryanclinton/uk-companies-house) | Access detailed UK filings, accounts, and full officer history beyond registry status |
| [sanctions-network-analysis](https://apify.com/ryanclinton/sanctions-network-analysis) | Cross-reference verified registry entities against OFAC, UN, EU, and UK sanctions lists |

### Limitations

- **No provincial/state registries** — Canadian coverage is federal only (Corporations Canada). Provincial registries (Ontario, BC, Alberta) require separate searches. UK coverage is Companies House England and Wales; Scottish and Northern Irish entities may have partial data.
- **No historical filing access** — the server returns current registration status and basic details. Historical annual returns, accounts, and document filings require direct Companies House or ASIC API access.
- **No beneficial ownership depth** — UK Companies House PSC data is included in raw results but the server does not trace multi-tier beneficial ownership chains. For full UBO mapping, use alongside a dedicated beneficial ownership tool.
- **OpenCorporates coverage varies** — quality and completeness varies significantly by jurisdiction. Some smaller Commonwealth jurisdictions have limited OpenCorporates data despite nominal coverage.
- **Wikipedia matching is fuzzy** — article linking uses a 15-character prefix inclusion check. For companies with common name fragments, false positive article links may appear. Check `wikipediaCorroborated` as a corroboration signal, not a primary verification.
- **Cache is per-instance** — the 5-minute in-memory cache applies within a single server instance. Cold starts (new Apify standby instance) begin with an empty cache.
- **180-second actor timeout** — each underlying registry actor has a 180-second timeout. Slow registry sources (OpenCorporates, GLEIF under high load) may time out and return empty arrays. The server continues with available data rather than failing.
- **Up to 50 records per source** — the network builder processes at most 50 records per registry and 500 per actor dataset fetch. Very common names may have more matches than are analyzed.
- **No real-time status polling** — data reflects registry state at query time. Apify platform scheduling is available for periodic re-verification workflows.

### Integrations

- [Zapier](https://apify.com/integrations/zapier) — trigger registry verification when a new vendor record is created in your CRM or procurement system
- [Make](https://apify.com/integrations/make) — build automated KYB workflows: new client intake form → registry check → compliance system update
- [Google Sheets](https://apify.com/integrations/google-sheets) — export registry report findings to a compliance tracking spreadsheet for review queues
- [Apify API](https://docs.apify.com/api/v2) — integrate registry verification into custom KYB platforms or compliance portals via REST API
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — notify compliance systems when registry checks complete or when spending limits are approached
- [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — embed registry verification as a tool in RAG pipelines for document-grounded compliance analysis

### ❓ FAQ

**How many Commonwealth countries does this MCP server cover?**
Direct registry access covers Australia (ABN Lookup), Canada (Corporations Canada federal registry), New Zealand (Companies Office), and the United Kingdom (Companies House). OpenCorporates extends this to 140+ jurisdictions globally. GLEIF LEI provides entity identification across all financial market jurisdictions worldwide.

**How current is the registry data returned?**
Data is fetched live at query time from each registry via the underlying Apify actors. Results reflect the current published state of each registry at the moment of the call — there is no pre-cached or stale batch data in the system.

**How does the A–F verification grade work?**
The grade is a composite of four components: registration score (capped at 0.4 for 4+ registry records), LEI presence (0.25), Wikipedia corroboration (0.15), and name consistency (0.05–0.20 depending on number of name variations found). Scores ≥0.8 = A, ≥0.6 = B, ≥0.4 = C, ≥0.2 = D, below 0.2 = F.

**Can I search by company registration number instead of name?**
Yes. All four country-specific tools and the cross-registry tools accept registration numbers: ABN for Australia, corporation number for Canada, NZBN for New Zealand, and company registration number for UK. Searching by number returns exact matches and avoids ambiguous name results.

**What does a concordance score of 0.0 mean?**
A concordance score of 0.0 means none of the registration records found show an active, registered, or current status. All statuses are dissolved, struck off, inactive, or unknown. This is a material finding that warrants investigation before proceeding with onboarding or transactions.

**Is it legal to use Commonwealth corporate registry data this way?**
All data sources are publicly available government registries. ABN Lookup, Companies House, NZ Companies Office, and Corporations Canada publish their data for public access. OpenCorporates and GLEIF are licensed data aggregators. See [Apify's guide on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

**How is this different from subscribing to a KYB platform like Kyckr or Bureau van Dijk?**
KYB platforms charge $500–2,000/month for subscription access. This MCP server uses pay-per-call pricing at $0.05 per tool call — suitable for teams with variable verification volumes or AI agent workflows where cost scales with actual usage. It does not include credit scores, adverse media, or complex UBO mapping that enterprise KYB platforms provide.

**Can this MCP server run on a schedule for continuous monitoring?**
Yes. The actor runs on the Apify platform, which supports cron-based scheduling. Configure a schedule to re-verify entities periodically and use webhooks to notify your compliance system when new `critical` findings appear in `generate_registry_report`.

**What happens if one registry source is unavailable during a query?**
The `runActor` function catches errors from individual actor calls and returns an empty array rather than throwing. The query continues with results from the remaining available sources. The response will reflect data from whichever sources completed successfully, which you can infer from missing jurisdiction entries in the output.

**Can I use this with an AI framework like LangChain or an AI coding assistant?**
Yes. The server implements MCP protocol version 1.0 and works with any MCP-compatible client: Claude Desktop, Cursor, Windsurf, Cline, and frameworks supporting the MCP SDK. The `/mcp` Streamable HTTP endpoint is the recommended connection method for programmatic clients.

**Does coverage include Australian state-level business names?**
The Australia actor queries the ABN Lookup registry, which covers all Australian Business Numbers issued by the ATO regardless of state. Business names registered at the state level (e.g., NSW Fair Trading) are not included — ABN Lookup covers the federal ABN registry only.

**How do I get an Apify token to use this server?**
Create a free account at [apify.com](https://apify.com). Your API token is in Settings > Integrations. The free plan includes $5/month in credits — enough for 100 tool calls.

### Help us improve

If you encounter issues, help us debug faster by enabling run sharing:

1. Go to [Account Settings > Privacy](https://console.apify.com/account/privacy)
2. Enable **Share runs with public Actor creators**

This lets us see your run details when something goes wrong. Your data is only visible to the actor developer, not publicly.

### Support

Found a bug or need a feature? Open an issue in the [Issues tab](https://console.apify.com/actors/commonwealth-corporate-registry-mcp/issues) on this actor's page. For enterprise integrations or custom KYB workflows, reach out through the Apify platform.

# Actor input Schema

## Actor input object example

```json
{}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/commonwealth-corporate-registry-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/commonwealth-corporate-registry-mcp").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 '{}' |
apify call ryanclinton/commonwealth-corporate-registry-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Commonwealth Corporate Registry MCP",
        "description": "Multi-jurisdiction corporate registry intelligence for AI agents via the Model Context Protocol.",
        "version": "1.0",
        "x-build-id": "yEYNRhJjecGo38m4S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~commonwealth-corporate-registry-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-commonwealth-corporate-registry-mcp",
                "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/ryanclinton~commonwealth-corporate-registry-mcp/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-commonwealth-corporate-registry-mcp",
                "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/ryanclinton~commonwealth-corporate-registry-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-commonwealth-corporate-registry-mcp",
                "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",
                "properties": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```