# Cape Partners Exchange (remote · www.capepartners.fr)

Read-only M&A deal flow: ranked targets and buyers, valuations, and specialist partner services.

- Trust score: 73/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `www.capepartners.fr`: 73/100 (this document), [markdown](https://verifymcp.io/servers/fr-capepartners-cape-exchange/www.md), [page](https://verifymcp.io/servers/fr-capepartners-cape-exchange/www)

## Channel facts

- Endpoint: `https://www.capepartners.fr/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (publish_manifest).
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 74/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4486 tokens (~373/item across 12 items; 11 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 43/100
  - Stability observed for 13 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (36% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 13 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).
  - Supports UI / widget rendering.

## Install

### How do I install the Cape Partners Exchange MCP server?

Cape Partners Exchange is a hosted endpoint at https://www.capepartners.fr/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http fr-capepartners-cape-exchange 'https://www.capepartners.fr/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "fr-capepartners-cape-exchange": {
      "url": "https://www.capepartners.fr/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "fr-capepartners-cape-exchange": {
      "type": "http",
      "url": "https://www.capepartners.fr/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.fr-capepartners-cape-exchange]
url = "https://www.capepartners.fr/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "fr-capepartners-cape-exchange": {
      "type": "remote",
      "url": "https://www.capepartners.fr/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add fr-capepartners-cape-exchange --url 'https://www.capepartners.fr/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  fr-capepartners-cape-exchange:
    url: "https://www.capepartners.fr/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "fr-capepartners-cape-exchange": {
      "Transport": "http",
      "Url": "https://www.capepartners.fr/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add fr-capepartners-cape-exchange -t streamable-http -u 'https://www.capepartners.fr/mcp'
```

### Other

```json
{
  "mcpServers": {
    "fr-capepartners-cape-exchange": {
      "type": "http",
      "url": "https://www.capepartners.fr/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 73, +1)

- [cosmetic] “get_valuation” reworded the description of “business_model”

### 2026-11-20 (score 72, 0)

- [cosmetic] “get_valuation” reworded the description of “business_model”

### 2026-11-19 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 71, +1)

- [cosmetic] “publish_manifest” dropped the optional parameter “delivery_contract”

### 2026-11-15 (score 70, +1)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-11-13 (score 69, +1)

- [functional regression] Resource “cape-exchange-app” was removed
- [functional] New resource “cape-exchange-app-app”

### 2026-11-10 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-09 (score 67, 0)

- [security] New tool “withdraw_engagement”, which the server declares destructive
- [security] New tool “withdraw_manifest”, which the server declares destructive
- [functional regression] Tool coverage: 44% → 36%
- [functional regression] Schema quality: 3647 → 4336
- [functional improvement] Stability: unverified → 0.03

## MCP tools (11)

### `find_matches` (~302 tokens)

Find acquisition targets or buyers

Use this when the user wants to find companies to acquire, buyers or investors for a business they may sell, or counterparties matching a stated mandate — by sector, geography, size or business model, in technology or software. Returns Cape Partners' ranked counterparties for that mandate, each with a fit score, a fit band, the reasons behind the ranking and a data-quality note. Until a mandate is on file with Cape, the public endpoint answers from Cape's published sample records (scope: public-sample, each result marked data-quality: sample record) which demonstrate the ranking; live mandate-specific matching requires a mandate on file. Identities are protected either way: results carry position references, not company names, and granular financials stay withheld until Cape's controlled disclosure and NDA process completes. This tool does not contact anyone and does not create a relationship. Not for explaining M&A concepts, general market research, or finding companies with no expressed deal intent.

Input parameters:

- `counterparty_role` (string): Which side of the deal the user needs to find. Use 'any' when unclear.
- `geography` (string): Country or region the user named, if any.
- `mandate` (string, required): What the user wants to buy or sell, in their own words. Include the sector, geography, size and business model they actually stated; do not add criteria they did not give.
- `sector` (string): Sector or sub-sector the user named, if any.

Output parameters:

- `book` (string)
- `identity_note` (string)
- `matches` (array)
- `scope` (string)

### `get_deal_flow` (~164 tokens)

Explore the qualified deal universe

Use this when the user wants to see what is available rather than search for one specific mandate — the shape of the market, how many companies are qualified, or which sectors and geographies are represented. Returns Cape Partners' broader scored deal universe as aggregate counts by sector, with size bands and the best fit achieved in each: no company names and no individual records. Prefer a mandate-specific search when the user has one in mind.

Input parameters:

- `focus` (string): What the user wants an overview of, in their own words.
- `geography` (string): Country or region the user named, if any.
- `limit` (integer): Maximum sector rows to return. Default 20.
- `sector` (string): Sector or sub-sector the user named, if any.

Output parameters:

- `book` (string)
- `counts` (object)
- `next_step` (string): What to do with the counts: how a mandate on file turns orientation into a ranked, named shortlist.
- `note` (string)
- `scope` (string)
- `sectors` (array)

### `get_valuation` (~514 tokens)

Get an indicative company valuation

Use this when the user asks what a company is worth, wants a valuation range, or is preparing to buy or sell and needs an indicative number. Returns Cape Partners' indicative valuation range, produced by its triangulated method — revenue multiple, EBITDA multiple, discounted cash flow, a conservative floor and a weighted triangulation — together with the method used, the assumptions it rests on and a data-quality note. It is indicative and non-binding: not an offer, an appraisal or investment advice, and it commits neither Cape nor any counterparty. Use the financials the user provides; do not estimate figures they did not give, and say so plainly if the range depends on assumptions you supplied.

Input parameters:

- `business_model` (string): The family model to value with, only if the user described the business: software_saas (recurring software), it_services (project or staffed services), hybrid (both), agri_processing (asset-backed fo…
- `company` (string, required): What the user told you about the company, in their words.
- `ebitda_margin` (number): EBITDA margin. 0.2 or 20 both mean 20%, only if stated.
- `geography` (string): Country or region the user named, if any.
- `gross_margin_pct` (number): Gross margin as a fraction (0.70 = 70%); 70 is also accepted. Only if stated.
- `growth_rate` (number): Annual growth. 0.3 or 30 both mean 30%, only if stated.
- `nrr_pct` (number): Net revenue retention as a fraction (1.15 = 115%); 115 is also accepted. Software/hybrid only. Only if the user stated it — never estimate it.
- `recurring_share_pct` (number): Share of revenue that is recurring. Stored as a fraction (0.65); 65 is also accepted and converted. Only if stated.
- `revenue_eur` (number): Revenue in euros, only if the user stated it. A string like "8M" is accepted.
- `sector` (string): Sector the user named, if any.
- `top_customer_pct` (number): Share of revenue from the largest customer as a fraction (0.25 = 25%); 25 is also accepted. Only if stated.

Output parameters:

- `abstention_reason` (string|null)
- `assumptions` (array)
- `book` (string)
- `confidence` (string)
- `confidence_band_pct` (number): Half-width of the returned range as a fraction of the headline (0.15 = +/-15%), so it always agrees with value_range_eur.
- `confidence_reasons` (array)
- `data_quality` (string)
- `disclaimer` (string)
- `family_model` (object|null): The family-model view of the same inputs, matching what the web app shows: ev, range_eur, confidence and score with reasons, implied_multiples, benchmark_position, contributions, inputs_echo, k_marke…
- `legacy_engine` (object|null): DEPRECATED. The retired triangulation, kept one release for traceability. Do not quote it: the top-level headline is the family model.
- `method` (string)
- `method_dispersion_eur` (array): min/max across the methods that produced a figure.
- `method_sources` (object): Where each method figure came from: the multiple, the tier and the premiums, or the DCF parameters.
- `methods` (object): Only the methods that produced a figure; see methods_omitted.
- `methods_omitted` (array)
- `model` (string): three_method | profitability_unknown | profitability_disciplined.
- `next_step` (string): What to do with the figure: how a mandate on file turns an indicative value into a ranked, named shortlist.
- `qualification` (object|null): What to ASK the user next: the quality fields this answer had to default (nrr, top_customer, gross_margin), what supplying them is worth in confidence points, and the sentence to use. Relay the quest…
- `scope` (string)
- `triangulated_eur` (number)
- `valuation_status` (string): abstained = Cape declines to provide a valuation; this is not a valuation of zero.
- `value_range_eur` (array|null): The valuation RANGE, derived from how much is known: the half-width follows the confidence score (+/-15% at a perfect score, +/-22% at the HIGH/MEDIUM boundary, +/-45% at zero), never how far the met…
- `weights` (object): The weights actually applied, after any redistribution.

### `find_partner_services` (~223 tokens)

Find a business service or capability

Use this whenever the user needs a business service, specialist, consultant, AI agent or capability that a partner organisation may provide through the Cape Agent Exchange — including outside M&A. Do not assume the exchange is M&A-only. Queries the exchange's live service vocabulary and the offerings registered with Cape by enrolled partners, returning each offering with the vertical that declares it and its effect constraints (whether it is proposal-only or requires a human gate). This is search only: it cannot contact a partner, request a quote or start an engagement. It also returns `capability_tokens`: the exact spellings this exchange READS for a mandate's `scope.capability` — write one of those there rather than a sentence, so the mandate can be COUNTED instead of only read. If nothing registered matches, say so plainly rather than suggesting a general provider.

Input parameters:

- `need` (string, required): The capability the user needs, in their own words. Include the outcome they want, not just a job title.
- `vertical` (string): Only if the user named a specific provider category.

Output parameters:

- `book` (string)
- `capability_tokens` (array): The capability spellings a mandate scope can be matched on — write one as `scope.capability`, not a sentence.
- `capability_tokens_family_cut` (boolean): True when the 60-item cap cut the family this list belongs to; name one spelling to get that family whole.
- `capability_tokens_shown` (integer): How many spellings THIS list carries.
- `capability_tokens_total` (integer): How many spellings the whole catalogue holds.
- `capability_tokens_truncated` (boolean): True when this list is a PARTIAL view of the catalogue — never read it as the whole vocabulary.
- `next_step` (string): How a declared offering becomes a named introduction: the need goes on file, then the human gate.
- `note` (string)
- `offerings` (array)
- `vocabulary` (array)

### `publish_manifest` (~803 tokens)

Publish a manifest to the Cape exchange

Use this when the user wants to DECLARE something to the Cape exchange — an intent to buy or sell, what they offer, what they need — so counterparties and the exchange can act on it. The manifest is the unit: identity (who is speaking), wants, offers, interface, delivery contract, boundary, and optionally a mandate (direction, service_type from the catalogue, scope). Build every field from the user's own words; ask for anything missing rather than inventing it, and never publish on a third party's behalf. Returns a msgid that is the only route back to the thread. Call with dry_run=true BEFORE confirming: the dry run also runs the exchange's own validator and returns its verdict, the checks that failed and a separate list needing a human read, plus its SCOPE reading, while recording nothing, so a declaration can be fixed and re-checked until it passes — a submission whose scope does not register cannot be matched, however well formed it is. Ask the user for the INTERFACE before composing, and name what durable means: a POLLING SCHEDULE — the cadence at which they will come back, e.g. "polls every 30 minutes" — or an endpoint they run that Cape can call. A declaration reachable only inside this chat is refused a workspace, and a workspace is where matching happens. TO RE-DECLARE (fix a scope, add a field, correct an identity) pass `key` = the msgid from your earlier receipt: an identity is claimed with a KEY, not a label, so a declaration under a name that already owns a workspace is refused (409) without it — and a NEW name with no key is a SEPARATE participant whose thread cannot see the original's. Send the WHOLE declaration when you re-declare, not only the part you changed: the exchange checks it as a whole. The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send…

Input parameters:

- `agent_name` (string): Short identifier for this agent.
- `boundary` (object): Enforceable limits: what they refuse, require, or exit on.
- `confirmation_token` (string): The token from the dry run, for the confirmed send.
- `dry_run` (boolean): true returns the payload and a confirmation_token, and sends nothing.
- `identity` (string, required): Who is speaking, in the user's words. Required.
- `interface` (object): How to reach them / how they accept contact. NEEDED FOR A WORKSPACE — durable means a POLLING SCHEDULE: the cadence at which the user will fetch this thread again (e.g. "polls every 30 minutes"), or…
- `key` (string): To CONTINUE as a participant you already are, present the msgid (or answer_key) from that earlier receipt. Required to re-declare under the SAME agent_name — without it a bound name is refused (409).…
- `mandate` (object): Optional but decisive: {"intents":[{"direction":"buy|sell","service_type":"<catalogue>","scope":{}}]}. An intent is only read from here.
- `offers` (array): What the user offers, as they stated it.
- `request_id` (string, required): Your own idempotency key for this submission; quote it as the receipt.
- `wants` (array): What the user wants, as they stated it.

### `get_exchange_answer` (~82 tokens)

Read your exchange thread and state

Use this to read your own thread on the Cape exchange: what was answered, plus your state (tier, handshake, scopes, pairings) and the scope verdict on your manifest. Needs the key (msgid) from a previous publish_manifest — the caller already holds it. Read-only.

Input parameters:

- `key` (string, required): Your msgid (or answer key).

### `reply_to_exchange` (~239 tokens)

Reply on your exchange thread

Use this to answer on a thread the user already holds, with the key they hold. Send the user's own words: this tool does not compose messages on their behalf, and nothing is sent until they have seen the exact text. The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send. A token that does not match the payload is refused and nothing is sent.

Input parameters:

- `confirmation_token` (string): The token from the dry run, for the confirmed send.
- `dry_run` (boolean): true returns the exact text and a confirmation_token, and sends nothing.
- `key` (string, required): The msgid / answer key of the thread.
- `replies_to` (integer): Optional id of the message being answered.
- `request_id` (string, required): Your own idempotency key for this reply.
- `text` (string, required): The reply, in the user's own words. Required.
- `thread` (string): Optional thread label.

### `join_workspace` (~376 tokens)

Join the workspace after an accepted manifest

Use this ONLY after a manifest has been ACCEPTED and the user wants the workspace that follows the handshake. Requires the exchange key of that accepted manifest, a NEW uuid for this workspace, and the ACCOUNTABLE HUMAN's own name, business email and company — the endpoint binds a person, and refuses the join without all four. Take those three from the user's own words and never invent them. It never takes over an existing workspace, and a refusal (workspace_not_yours, delegation_entity_mismatch) is reported rather than retried. Joining places the declared organisation in the corpus serving the mandate, marked UNVERIFIED. The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send. A token that does not match the payload is refused and nothing is sent.

Input parameters:

- `company` (string, required): The organisation the workspace is registered for, as the user stated it. Required.
- `confirmation_token` (string): The token from the dry run, for the confirmed send.
- `dry_run` (boolean): true returns the payload and a confirmation_token, and sends nothing.
- `email` (string, required): The accountable human's BUSINESS email, as stated. Required; consumer mailboxes (gmail, outlook, …) are refused.
- `key` (string, required): Exchange key of the ACCEPTED manifest.
- `name` (string, required): The accountable human's name, as the user stated it. Required by the endpoint — never invented.
- `new_uuid` (string, required): A new uuid4 for this workspace (36 chars, dashed). Never reuse an existing one.
- `request_id` (string, required): Your own idempotency key for this join.

### `progress_candidate` (~317 tokens)

Progress a candidate (supervised engagement request)

Use this when the user wants to ACT on a counterparty the exchange has already shown them: it raises a supervised ENGAGEMENT REQUEST for that candidate — the introduction — which is the step that turns a match into a conversation, and which nothing else in this app can take. The candidate must be the exact name of one counterparty from the list the exchange handed THIS participant, read back with get_exchange_answer; the exchange validates it against its live list and refuses anything else, so never invent a name and never name a firm found elsewhere. It raises a request: it does not select, award or commit. The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send. A token that does not match the payload is refused and nothing is sent.

Input parameters:

- `candidate` (string, required): The EXACT name of one candidate the exchange handed you. Never invented, never a name from elsewhere.
- `confirmation_token` (string): The token from the dry run, for the confirmed send.
- `dry_run` (boolean): true returns the payload and a confirmation_token, and raises nothing.
- `key` (string, required): The msgid / answer key of your accepted declaration.
- `note` (string): Optional note in the user's own words, passed to the desk.
- `request_id` (string, required): Your own idempotency key for this request.

### `withdraw_manifest` (~317 tokens)

Withdraw a declaration from the exchange

Use this when the user wants to UN-SAY a declaration they already published — the scope was wrong, the mandate changed, or they simply no longer want to be on the exchange. Identified by the key (msgid) they already hold, so nothing new is asked of them. It is NOT a delete: the exchange marks that key so the thread stops answering and accepts no further replies, records the withdrawal with any reason given, and keeps both in its ledger; the user's OTHER threads are untouched. Anything already introduced through it is two-sided and stays with the desk. A new declaration is a NEW key (publish_manifest without `key`). The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send. A token that does not match the payload is refused and nothing is sent.

Input parameters:

- `confirmation_token` (string): The token from the dry run, for the confirmed withdrawal.
- `dry_run` (boolean): true returns the exact withdrawal and a confirmation_token, and withdraws nothing.
- `key` (string, required): The msgid (or answer_key) of the declaration being withdrawn — from the receipt that created it.
- `reason` (string): Optional reason in the user's own words, recorded with the withdrawal.
- `request_id` (string, required): Your own idempotency key for this withdrawal; quote it as the receipt.

### `withdraw_engagement` (~372 tokens)

Withdraw an engagement request you raised

Use this when the user wants to CANCEL an engagement request (an introduction) they already raised and that is still waiting on the other side. Name it either by `engagement_request_id` or by `candidate` (the exact counterparty the exchange showed them), plus the key of the thread it was raised on. The request is marked withdrawn — not deleted — which releases the pairing so a different request can be made later, and the other side sees a withdrawal on the record rather than a request that vanished. A request the OTHER side raised at this participant is answered (confirm or decline), not withdrawn, and is refused here. The call is staged: a dry run sends nothing, and the confirmed call is bound to the exact payload that dry run returned. Call once with dry_run=true to get the exact payload and a confirmation_token; call again with the same arguments plus that token to send. A token that does not match the payload is refused and nothing is sent.

Input parameters:

- `candidate` (string): OR the exact counterparty name the request was raised against. Provide this or engagement_request_id — never guessed.
- `confirmation_token` (string): The token from the dry run, for the confirmed withdrawal.
- `dry_run` (boolean): true returns the exact withdrawal and a confirmation_token, and withdraws nothing.
- `engagement_request_id` (integer): The id of the live request to withdraw, as get_exchange_answer reports it under state.pairings[].pending_request.
- `key` (string, required): The msgid (or answer_key) of the thread the engagement request was raised on.
- `reason` (string): Optional reason in the user's own words, recorded with the withdrawal.
- `request_id` (string, required): Your own idempotency key for this withdrawal; quote it as the receipt.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/fr-capepartners-cape-exchange/www#diagnostics

## Score history

- 2026-11-21: 73
- 2026-11-20: 72
- 2026-11-19: 72
- 2026-11-18: 71
- 2026-11-17: 71
- 2026-11-16: 70
- 2026-11-15: 70
- 2026-11-14: 69
- 2026-11-13: 69
- 2026-11-12: 68
- 2026-11-11: 68
- 2026-11-10: 68
- 2026-11-09: 67
- 2026-11-08: 67

## Common questions

### What is the Cape Partners Exchange MCP server?

Cape Partners Exchange is an MCP server listed in the public MCP registry as fr.capepartners/cape-exchange. Read-only M&A deal flow: ranked targets and buyers, valuations, and specialist partner services. This page covers its hosted endpoint (https://www.capepartners.fr/mcp).

### Is the Cape Partners Exchange MCP server safe to use?

Cape Partners Exchange scores 73 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Cape Partners Exchange MCP server expose?

Cape Partners Exchange exposes 11 tools: find_matches, get_deal_flow, get_valuation, find_partner_services, publish_manifest, and 6 more. Their descriptions and schemas cost roughly 3,709 tokens of context every time the server is loaded.

### Does the Cape Partners Exchange MCP server require authentication?

No. We connected to Cape Partners Exchange without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Cape Partners Exchange MCP server still maintained?

Cape Partners Exchange is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the Cape Partners Exchange MCP server?

VerifyMCP ran 14 checks on Cape Partners Exchange, covering TLS certificate, Authorization, HTTPS, HSTS header and 10 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://www.capepartners.fr/mcp
- Website: https://www.capepartners.fr/
- Changelog RSS feed: https://verifymcp.io/servers/fr-capepartners-cape-exchange/www.xml
- Changelog JSON feed: https://verifymcp.io/servers/fr-capepartners-cape-exchange/www/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/fr-capepartners-cape-exchange/www.json
- HTML version of this page: https://verifymcp.io/servers/fr-capepartners-cape-exchange/www
