InterfaceDelta

Look up any MCP service's tools, change history and breaking changes. Read-only, no account

View on interfacedelta.com

Hosted MCP Server

npx add-mcp 'https://interfacedelta.com/mcp/public'

Installs into Claude Code, Codex, Cursor and more

Documentation

Contents

Ask your AI assistant about your services

Tool names are stable API and keep their original names.

Connect InterfaceDelta to Claude, Codex, Cursor or another AI assistant that supports MCP. You can then ask about the services you follow in plain language. The assistant reads the same records you see on the website. It cannot change anything or start new scans.

Server address · read-only · sign-in required for your own data https://interfacedelta.com/mcp

Things to try

  • “What changed at rupturebrief.com this week?”
  • “Did any service I follow have a breaking change? What should I do about it?”
  • “Explain the latest Change alert in plain English and give me its Impact Brief as markdown.”
  • “Show the latest Passport for rupturebrief.com. Which interfaces does it expose?”
  • “Which of my repositories have lockfile decisions, and were they delivered?”
  • “Where do my alerts go, and are those destinations healthy?”
  • “Am I close to my plan’s limits?”
  • “List the services our Acme team workspace follows.”
  • “Search the public atlas for rupturebrief and show its labels.”

Words you’ll see

Service

A website or API you follow on InterfaceDelta.

Passport

A recorded snapshot of a service’s machine-readable interfaces (MCP, OpenAPI, A2A and others).

Change

A difference between two Passports of the same service.

Change alert

A change that matters to you, with an AI-written explanation and a suggested next step.

Lockfile decision

The decision InterfaceDelta recorded for a repository you connect: whether the change affects your dependencies, and where it was delivered.

Workspace

A shared team account. Without one, the assistant reads your personal account.

Connect in 2 minutes

Every client needs two steps: add the server, then sign in. Signing in opens the InterfaceDelta sign-in page in your browser. Use the same email you use on the website.

Signing in lets your assistant read your InterfaceDelta account: the services you follow, changes and decisions, alert routing (secrets hidden), plan and usage, and workflows. It can only read.

Connected before 14:18 UTC on 5 November 2026? Your old sign-in no longer works and every request answers “Invalid or inactive OAuth access token”. Run your client’s sign-in step again.

Codex · codex-cli 0.152.1

Add the server, then sign in in your browser. Over SSH, add --no-browser to the login command and follow the callback prompt. Check with codex mcp get interfacedelta --json, then start a new session.

Official setup source ↗

codex mcp add interfacedelta --url https://interfacedelta.com/mcp --oauth-client-registration cimd --oauth-resource https://interfacedelta.com/mcp
codex mcp login interfacedelta --oauth-client-registration cimd

Authentication

WorkOS OAuth

Local browser

Supported

Headless VPS

Supported

Verified

Not yet verified end-to-end

Check that it worked

Start a new chat or session and ask: “Show my InterfaceDelta account overview.” You should see your plan and usage. If you see a sign-in message, repeat the sign-in step.

Public, no sign-in

Connect to https://interfacedelta.com/mcp/public for Passport share views and public atlas search and detail. This endpoint always uses public visibility, even if a client sends credentials.

Listed in the Official MCP Registry as com.interfacedelta/atlas and independently checked by mcptry:

mcptry status for com.interfacedelta/atlas

claude mcp add --transport http interfacedelta-public https://interfacedelta.com/mcp/public

Add to Claude

InterfaceDelta is in Claude’s connector directory. Open InterfaceDelta in the Claude directory ↗ and add it; no sign-in or key is needed for the public atlas. Claude Code users can run the command above.

Add to Cursor

Cursor installs remote servers through its own deep-link format, which is documented in Cursor’s install-links guide ↗. The link asks Cursor to add the public endpoint; Cursor shows what it will install before connecting:

Add to Cursor ↗

The configuration encoded in that link

{"url": "https://interfacedelta.com/mcp/public"}

First three calls: your first three questions

Ask these in order. Replace rupturebrief.com with a domain you follow. The tool your assistant calls is shown in brackets.

  1. “Show my InterfaceDelta account overview.” (get_account_overview). This confirms you are signed in and shows your plan, usage and limits.
  2. “List the services I follow.” (list_monitored_services). This shows each service’s address, latest check and target key.
  3. “Show the latest Passport for rupturebrief.com and what changed recently.” (get_latest_passport, then list_target_changes)

The same calls as raw tool input

For clients that let you call tools directly.

get_account_overview  {}
list_monitored_services  {"limit": 20}
get_latest_passport  {"target": "rupturebrief.com"}

What an answer looks like

An illustrative answer to “Search the public atlas for payment services and show the labels of the first one”:

Illustrative answer · public atlas

search_atlas, then get_atlas_entry. The service is made up; your assistant’s wording will differ.

The public atlas has 2 matches for “payment”:
  https://pay.example.com      MCP, MCP Server Card, ARD   last checked Nov 4, 2026
  https://payments.example.net MCP                         last checked Nov 2, 2026

Labels for https://pay.example.com:
  Label state               Current
  Interfaces found          MCP, MCP Server Card, ARD
  Tools listed              1
  Sign-in declared          None listed
  Change since last check   First check (baseline)
  AI readings (beta)        1 tool examined; 0 can move money,
                            delete data or send messages
  Disagreements             0 (places where the service's own tool
                            flags disagree with the AI reading)

Tools

You don’t need to name tools. Ask your question and the assistant picks the right tool. This list shows what it can read. Account lists accept 1–50 items per page; history and changes accept 1–100 (default 20).

Your services

  • list_monitored_services Services you follow, with target keys, last check and email settings.
  • list_recent_inspections Inspections recorded for you, as on Following.
  • get_latest_passport The latest Passport for a service. Accepts a domain, URL or target key.
  • list_target_history Every recorded check of a service, newest first.
  • list_target_changes Field-by-field changes between checks of a service.
  • get_passport One exact Passport by its observation ID. Works without sign-in.

Changes & decisions

  • list_signals Changes that matter to you, with AI-written explanations and next steps.
  • get_signal One change alert in full, by its id from list_signals.
  • list_lockfile_watches Repositories and branches you connect, and their sync status.
  • list_lockfile_decisions Decision cards and delivery states; use get_lockfile_decision for full linked values.
  • get_lockfile_decision One decision in full, by its id.

Reports

  • get_impact_brief The Impact Brief for a change alert as markdown, the same file the website downloads.

Account & settings

  • get_account_overview Start here: your plan, usage and limits.
  • list_workspaces Team workspaces you belong to, with their ids.
  • get_routing Where alerts and decisions are delivered, and whether delivery is healthy.
  • list_workflows Your workflow profiles and their dependencies.
  • get_workflow One workflow and which current changes affect it.
  • list_api_tokens API token names, scopes and last use. Never the token itself.
  • list_connected_agents AI assistants connected to your account.
  • list_account_activity Recent activity on your account.

Public atlas

  • search_atlas Search public services by domain or name. Works without sign-in.
  • get_atlas_entry A public service’s labels, Passport and AI readings. Works without sign-in.

Finding a service

Use the domain. “rupturebrief.com” or “https://rupturebrief.com” is enough for any service you or your selected workspace follows. If you follow several addresses on the same domain, such as a website and its MCP endpoint, use the full address, for example “https://rupturebrief.com/mcp”.

The target key is optional. It is the exact identifier of one followed address. It looks like sha256: followed by 64 letters and digits. To copy it:

  • On Following, open a service to find Target key with a Copy target key button.
  • On a Passport page, the facts box shows Target key with a Copy button.
  • Or ask your assistant: “List my services with their target keys.”

These values look similar but are not target keys:

  • the 40-character ARD spec commit shown next to a protocol on a Passport. It identifies a version of the protocol specification, not your service;
  • a Passport’s fingerprint, which also starts with sha256:. It identifies one snapshot, not the service.

Services you don’t follow answer “No accessible service matches”. Ask about them through the public atlas instead (“Find rupturebrief in the atlas”), or start following them on the website.

A specific snapshot has an observation ID, the last part of a Passport address after /observations/. Your assistant can also find these with list_target_history.

Team workspaces

Tools accepting workspaceId: get_passport, get_latest_passport, list_target_history, list_target_changes, list_monitored_services, list_recent_inspections, list_signals, get_signal, get_impact_brief, list_lockfile_decisions, get_lockfile_decision, get_routing, list_api_tokens, list_workflows, get_workflow, list_lockfile_watches.

The assistant reads your personal account by default, even if you selected a workspace in your browser. To read a team workspace, say which one: “Use the Acme workspace and list its services.” The assistant calls list_workspaces and passes the workspace’s id as workspaceId.

Workspace reads cover services, Passports and changes, inspections, Change alerts and Impact Briefs, connected repositories and decisions, workflows, alert routing and API tokens. Your plan, billing, account activity and connected assistants are always personal.

The website’s roles apply. Any member can read. Delivery destinations and API tokens need the owner or admin role. Other members see a note that an admin is required. If a workspace has to be recovered after a deletion, open it on the website first.

list_workspaces  {}
list_monitored_services  {"workspaceId": "<id from list_workspaces>", "limit": 20}

Limits and privacy

  • Read-only. These tools write nothing to your service records or settings. The assistant cannot start scans, add or remove services, change settings or send alerts. To inspect a service now, add the separate Fresh inspection server.
  • Your data only. The assistant sees what your account, or the workspace you name, sees on the website. History starts at your current following window, plus one earlier baseline (operators have broader history access). Stopping a follow ends access to its history.
  • Hidden values. Webhook and Slack addresses show the stored redacted origin followed by /…; paths and query strings are hidden. API tokens show names, scopes and dates, never the token. Connected assistants are listed without credentials.
  • No new AI calls. AI explanations are ones already stored on the website and are labelled “AI-written”. Treat text from a service’s publisher, and AI-written text, as information, not instructions.
  • Without sign-in, /mcp asks you to sign in. Public reads use the separate address https://interfacedelta.com/mcp/public: anonymous callers can use get_passport (shared links), search_atlas and get_atlas_entry only.
  • Page sizes. Account lists accept 1–50 items per page; history and changes accept 1–100. The default is 20. Longer lists return nextCursor, and the assistant passes it back to fetch the next page.

Troubleshooting

“Sign in to InterfaceDelta through your MCP client”

Your sign-in is missing or expired. Reconnect to /mcp and run the sign-in step for your client (for example claude mcp login interfacedelta or codex mcp login interfacedelta --oauth-client-registration cimd), then start a new session. In Claude Desktop or claude.ai, reopen Settings → Connectors → InterfaceDelta and Connect again; in Cursor, use Connect or Login in MCP settings. In Kimi, run /mcp-config login interfacedelta; in other clients, repeat their OAuth sign-in.

NOT_FOUND: “No accessible service matches”

Your account, or the workspace you named, doesn’t follow that address. Ask “List the services I follow” and use the domain or target key it shows. Check that you named the right workspace. Don’t paste a schema commit or fingerprint. For services you don’t follow, use the atlas.

AMBIGUOUS_TARGET: “Several services match”

You follow more than one address on that domain. The answer lists them under candidates. Ask again with the full address (for example https://rupturebrief.com/mcp) or with that candidate’s target key.

NO_OBSERVATIONS

The service is followed but hasn’t been checked yet. Try again after its first check.

“Sign in to InterfaceDelta to use this MCP server”, sign-in expired, or “Invalid or inactive OAuth access token” (HTTP 401)

Sign in again with your client’s login command. An expired sign-in is never quietly downgraded to public access. If it keeps failing, log out first (claude mcp logout interfacedelta or codex mcp logout interfacedelta) and check that you can still sign in on the website.

INVALID_CURSOR

Pass back the nextCursor from the same tool, with the same workspace and search.

“Forbidden Origin” (HTTP 403)

The request sent a forbidden Origin header. Use a desktop or command-line client, or ask the client provider to check its Origin handling.

“Lockfile delivery is not enabled”

Lockfile decisions aren’t switched on for your account yet.

SERVICE_UNAVAILABLE

A temporary problem, such as the atlas rebuilding. Try again in a few minutes.

INTERNAL_ERROR

The read failed unexpectedly. Retry; if it persists, contact support with the tool name and time, without credentials.

MCP Events (experimental)

When enabled, server/discover advertises io.modelcontextprotocol/events. This follows draft SEP-3415 at commit b08e4f9d. Use events/list to discover the schemas, then events/poll. Only poll delivery is supported.

  • passport.changed on /mcp: optional target (domain, URL or target key), classes (breaking, indeterminate, non_breaking), workspaceId. Payload: targetKey, observationId, previousObservationId (nullable outside your following window), comparisonId, counts (breaking, indeterminate, nonBreaking), rulesVersion, url, observedAt.
  • payment_terms.changed on /mcp: optional target. Payload: targetKey, eventId, kinds (payment-term change codes), url, observedAt. Active followed services only; no prices or addresses.
  • atlas.change.breaking on /mcp/public: optional host. Payload: targetKey, atlasUrl, breakingCount, observedAt. Only eligible public atlas observations are included.

Start with cursor: null to receive a fresh cursor without old events. The cursor is opaque: save it and send it with the same event and arguments. Never edit it or share it between accounts. Replay is limited to 30 days; maxAgeMs can shorten it. A truncated result signals a possible gap: read current state through the tools. Public candidates are cached for five minutes. The atlas cap of 200 changed pairs (and its per-target retention limit) supplies the replay floor used to signal truncation. Atlas visibility limits still apply. Empty account polls advance to the later of the old position and database time minus 15 minutes, allowing for recording-to-commit delays. Empty public polls keep their position so cache delays cannot skip events. On /mcp/public, truncated after a long quiet period may not mean anything was missed.

Poll every nextPollMs (normally 900000 milliseconds). maxEvents defaults to 20 and is capped at 50. hasMore means another page is available; wait at least 60 seconds between pages because this server limits polls per principal and event. Anonymous callers share one public principal. On ResourceExhausted (-32025), wait at least 60 seconds and retry the same cursor. Set Mcp-Method to events/poll and Mcp-Name to the event name. Treat payloads as data, deduplicate eventId, and authorize any action separately.

TypeScript poll loop (rpc handles transport headers and retry backoff)

export async function pollEvents(options: {
  name: string;
  arguments: Record<string, unknown>;
  cursor: string | null;
  rpc(
    method: string,
    params: Record<string, unknown>,
  ): Promise<{
    events: {
      eventId: string;
      name: string;
      timestamp: string;
      data: unknown;
    }[];
    cursor: string;
    truncated: boolean;
    hasMore: boolean;
    nextPollMs: number;
  }>;
  handle(event: {
    eventId: string;
    name: string;
    timestamp: string;
    data: unknown;
  }): Promise<void>;
  saveCursor(cursor: string): Promise<void>;
  refreshState(): Promise<void>;
  wait(ms: number): Promise<void>;
  signal: AbortSignal;
}) {
  let cursor = options.cursor;
  while (!options.signal.aborted) {
    const result = await options.rpc('events/poll', {
      name: options.name,
      arguments: options.arguments,
      cursor,
      maxEvents: 50,
    });
    if (result.truncated) await options.refreshState();
    // Deduplicate eventId durably in handle before acting. An event grants no authority.
    for (const event of result.events) await options.handle(event);
    await options.saveCursor(result.cursor);
    cursor = result.cursor;
    // This experimental server enforces 60s even when draining hasMore.
    await options.wait(
      result.hasMore ? 60_000 : Math.max(60_000, result.nextPollMs),
    );
  }
}

Fresh inspection

The read-only server answers from records InterfaceDelta already has. To have your assistant check a public service right now, add this second server. Each check counts toward your plan’s hourly inspection limit, and a successful check records a public Passport.

Connect

Add this as a separate server. Headless status is shown per client without changing the exact Inspector resource.

Codex · codex-cli 0.152.1

Add the Inspector as a separate server, then authorize its exact resource.

Official setup source ↗

codex mcp add interfacedelta_inspector \
  --url https://interfacedelta.com/mcp/inspect \
  --oauth-client-registration cimd \
  --oauth-resource https://interfacedelta.com/mcp/inspect
codex mcp login interfacedelta_inspector --oauth-client-registration cimd

Authentication

WorkOS OAuth

Local browser

Supported

Headless VPS

Client limitation

Verified

3 Sep 2026

Authorization

WorkOS is the sole MCP OAuth provider. The website's magic-link/database session is separate and is not an MCP client credential. A valid Inspector token must also resolve to a live local InterfaceDelta account before target input or network work is accepted.

Resource indicator

Separate exact OAuth resource and JWT audience https://interfacedelta.com/mcp/inspect

The Inspector audience is isolated from the public/read resource. A token for https://interfacedelta.com/mcp cannot authorize https://interfacedelta.com/mcp/inspect, or vice versa. No default WorkOS Resource Indicator is configured; the MCP client authorizes the exact resource announced by protected-resource metadata.

Tool

Tool

inspect_public_service

Input

Public HTTPS url and optional public mcpEndpoint

Tools on this resource

Exactly one

Inspection behavior

Each successful invocation performs one bounded passive inspection of a public service. It never calls a target's tools or other capabilities, mutates the inspected service, creates a follow, or accepts credentials for the target.

Persistence and retries

A successful invocation records one durable public Passport observation and its normal deterministic comparison. The operation is intentionally not idempotent: after a lost response, an explicit retry can consume another quota reservation and create another observation.

Security boundary

Authorization proves only that an InterfaceDelta account requested the observation. It does not prove ownership of the inspected target.

The caller's WorkOS bearer ends at InterfaceDelta's inbound authorization adapter and is never forwarded to the target. Public-HTTPS, DNS-pinning, redirect, time, size, and passive-scan restrictions remain in force.

Example

Tool request · synthetic target

The successful result would be a durable public InterfaceDelta observation.

{
  "url": "https://example.org"
}

Public and account-authorized MCP

InterfaceDelta serves /mcp using MCP 2026-07-28. This account-read endpoint requires WorkOS sign-in and challenges anonymous connections with HTTP 401. Public Passport share views and atlas reads are available without sign-in at /mcp/public. The canonical account endpoint is https://interfacedelta.com/mcp; the connection command is under Connect.

Two separate authorization resources

WorkOS Connect does not currently represent InterfaceDelta custom scopes. InterfaceDelta uses separate exact OAuth Resource Indicators and JWT audiences so fresh inspection authority cannot ride on the public/read authorization.

https://interfacedelta.com/mcp
  WorkOS authorization required → 22 account and public read tools

https://interfacedelta.com/mcp/public
  no sign-in → Passport share view and two atlas tools

https://interfacedelta.com/mcp/inspect
  WorkOS authorization required → inspect_public_service only

The read tools remain get_passport, get_latest_passport, list_target_history, and list_target_changes. The latest, history and changes tools answer only accounts that follow the target, from their current ownership period plus one baseline without a comparison. Ended subscriptions, anonymous readers and other callers get NOT_FOUND. Observations fetched by their own IDs outside the window receive the public share view with no comparison (comparisonWithheld: true), including for the owner. Owner observation detail includes optional comparison.recovery: the replay version, shared observation window, immediate predecessor ID and fingerprint, source base IDs (or null), and each replayed surface with its actual base ID. The inspection resource accepts the same url, optional type, and optional mcpEndpoint inputs as the Web Inspector. A successful call records exactly one durable public-target Passport observation and its normal comparison; it does not create, remove, or alter a follow. The result shows that comparison only to an account that follows the target. For any other account it is null with comparisonWithheld: true, even for a first observation, so a result never reveals whether anyone inspected the service before.

Input
{ "url": "https://service.example/mcp", "type": "auto" }

Compact durable result
{
  "observationId": "…",
  "targetKey": "sha256:…",
  "passportUrl": "https://interfacedelta.com/passport/…/observations/…",
  "observedAt": "…",
  "fingerprint": "sha256:…",
  "comparisonWithheld": false,
  "comparison": { "state": "baseline|unchanged|changed|incompatible_version", "highestClassification": "…", "counts": { "breaking": 0, "nonBreaking": 0, "indeterminate": 0, "informational": 0 } } | null,
  "summary": { "surfacesObserved": 0, "capabilitiesObserved": 0 }
}

The inspection resource is live and WorkOS-authorized. Keep the public/read MCP resource separate from the Inspector resource and its audience. InterfaceDelta Developer API tokens are not MCP OAuth tokens, and the caller's WorkOS credential is never passed to the inspected service.

Requesting an inspection proves only that an InterfaceDelta account requested the observation, not that it owns the target. The resulting observation may be available through existing public Passport and share surfaces. Connected-agent entries show read and inspection resource authorizations separately so either can be disconnected without presenting the other as revoked. The beta implementation permits 10 accepted fresh-inspection attempts per rolling hour per account on the Free plan; an explicit retry may record another observation.

OAuth and protocol details →

Discovery publication

InterfaceDelta publishes ARD v0.91 at /.well-known/ard.json, advertises it from the root page with rel="ard", retains /.well-known/ai-catalog.json only for predecessor compatibility, and publishes experimental Server Card metadata at /mcp/server-card. The chain is ARD entry → experimental MCP Server Card → live MCP endpoint. Runtime server/discover and tools/list remain authoritative. These routes are live in the public beta.

Back to contents

Next: How it works