Skip to main content
Danske Bank logo

MCP Service

Danske Bank's MCP Service lets AI agents work with our Premium APIs using the Model Context Protocol (MCP) - from browsing the catalog to actually calling live endpoints. It has two parts:

  • MCP Server - a hosted, read-only server for discovering APIs: search the catalog, fetch specifications, and get auth guidance. No District agreement, certificate, or subscription needed, but you must send an API key - see Authentication and rate limits.
  • MCP Proxy - a local package (@danskebank/mcp-api-proxy) you run yourself. It includes everything the MCP Server does, plus a call_endpoint tool for mock, sandbox, and production calls. For sandbox and production, it handles your client certificate and OAuth access token.

Availability: The MCP Server is open to anyone - no District agreement, certificate, or subscription needed, though an API key is required to connect (see below). Calling Sandbox or Production endpoints requires the same onboarding as any Premium API integration: a District agreement, a digital certificate, and a subscription to the APIs you want to call. The Mock Service needs none of this.

MCP Server vs. the local MCP Proxy - which should I use?

MCP Server (connect)MCP Proxy (get started)
What it doesSearch the catalog, fetch specs, business descriptions, and auth security guidanceEverything the MCP Server does, plus call_endpoint for API calls
SetupPoint your AI Agent at a URL and API key - nothing to installAdd a local command to your client; it runs the npm package with npx
Calling APIsMock endpoints can be called directly from any script - see belowMock calls, plus authenticated Sandbox and Production calls (Production is GET-only)
Onboarding required?No, but an API key is required - see Authentication and rate limitsNo for catalog/mock access; yes for Sandbox/Production - see Get started with Premium APIs
Best forExploring the catalog, browsing specs, prototyping against mock dataCalling APIs through your agent, using mock, sandbox, or production data

Use the MCP Server to explore the catalog; add the MCP Proxy when you want your agent to call APIs through MCP.

Key capabilities

CapabilityToolAvailable via
Discover valid filters (domains, types, environments)get_filtersMCP Server, MCP Proxy
Search and filter the API catalogsearch_apisMCP Server, MCP Proxy
Fetch details, versions, ownership and tags for an APIget_api_infoMCP Server, MCP Proxy
Fetch the full OpenAPI/AsyncAPI specificationget_endpoint_detailsMCP Server, MCP Proxy
Fetch the business description for an APIget_business_descriptionMCP Server, MCP Proxy
Get authentication and security setup guidanceget_auth_guideMCP Server, MCP Proxy
Call a Mock endpoint, or a Sandbox/Production endpoint with your credentialscall_endpointMCP Proxy only

How to use it

Connect to the MCP Server

VS Code

Using the UI: open the Command Palette and run MCP: Add Server, choose HTTP, and enter the URL https://mcp.danskebank.com/mcp. Give the server the ID danske-bank-apis, then select Global and Copilot Global. This stores the server in .copilot/mcp-config.json in your home folder, outside any project. If Copilot Global is not offered, see VS Code's Copilot harness requirements.

Then add your API key. Open that file and make sure the entry includes the headers block below. If the file already lists other servers, add danske-bank-apis next to them under mcpServers instead of replacing what is there. These examples use the portable top-level mcpServers format; to learn more, see the VS Code documentation.

{
  "mcpServers": {
    "danske-bank-apis": {
      "type": "http",
      "url": "https://mcp.danskebank.com/mcp",
      "headers": {
        "X-API-Key": "<your-api-key>"
      }
    }
  }
}

The key is stored as plain text in this personal file, and VS Code's portable configuration has no masked input prompt. Keep the file out of your projects and never commit it. To keep the key out of a configuration file altogether, use the MCP Proxy with a private settings file.

Older VS Code format. .vscode/mcp.json and the user-profile mcp.json use a servers object and support masked ${input:...} prompts. VS Code still reads them but labels them deprecated, and servers that need those prompts are not forwarded to Copilot sessions. Prefer the steps above.

Start danske-bank-apis from MCP: List Servers, start an agent session in Chat, and check that catalog tools such as get_filters and search_apis appear for it.

Claude Code

Claude Code is configured from the terminal - there's no separate UI for adding servers. Run:

claude mcp add --transport http danske-bank-apis https://mcp.danskebank.com/mcp --header "X-API-Key: <your-api-key>"

To learn more, see the Claude Code documentation.

Custom

Other MCP clients must support Streamable HTTP and custom HTTP headers. Use these connection details:

  • Name: Danske Bank MCP
  • URL: https://mcp.danskebank.com/mcp
  • Custom header: name X-API-Key, value your API key

The configuration format depends on your client. Follow its documentation rather than copying another client's JSON format, and preserve any existing server entries. Not every app's custom-connector screen supports API-key headers; if yours does not, use a compatible client or connect to the local MCP Proxy over stdio.

Trying APIs without the proxy

You can call the Mock Service directly with curl, a script, or your own HTTP client without running the MCP Proxy. These mock requests need no bank Client ID, client certificate, or private key.

The hosted MCP Server helps your agent discover APIs and retrieve specifications, but does not execute API calls. Catalog access through MCP still requires an MCP API key.

Once your agent has retrieved a specification (get_endpoint_details), it can use it to generate a script that calls the mock endpoint. A typical flow:

  1. "Find the Account Transaction & Balance API and show me its specification."
  2. "Write me a script that calls its mock endpoint and prints the response."

This lets you prototype against a real request/response shape before completing Premium API onboarding. The Mock Service intentionally returns random errors so you can test your error handling.

If you prefer to call mock endpoints using the call_endpoint tool, set up the MCP Proxy and use tier: mock. For sandbox or production calls, the proxy additionally needs your client certificate and OAuth settings from Premium API onboarding.

Get started with the MCP Proxy

There is nothing to install: your client starts the proxy with npx, which comes with Node.js and downloads the package from npm on the first start. The @latest tag makes every start use the newest published release.

  1. Check your prerequisites. Install Node.js 22.13.0 or newer within 22.x, or 24 or newer, and use an MCP-capable AI client. Node.js 20, 21, and 23 are not supported. Then request an MCP API key. The key is needed for catalog access, even if you only call the Mock Service. Mock calls need no bank Client ID, client certificate, or private key.

  2. Connect your client.

    VS Code. Open the Command Palette, run MCP: Add Server, choose Command (stdio), and enter npx -y @danskebank/mcp-api-proxy@latest. Give the server the ID danske-bank-apis, then select Global and Copilot Global. This stores it in .copilot/mcp-config.json in your home folder. Open that file and add your key, merging with any servers it already lists. If you already configured the direct HTTP connection above under the same ID, replace that entry or give the proxy a different ID.

    {
  "mcpServers": {
    "danske-bank-apis": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@danskebank/mcp-api-proxy@latest"],
      "tools": ["*"],
      "env": {
        "MCP_SERVER_API_KEY": "<your-api-key>"
      }
    }
  }
}

    -y answers the npx confirmation prompt for you, because a client starts the proxy without a terminal. The key is stored as plain text in this personal file; keep it out of your projects, never commit it, or keep it in a private settings file instead (see the getting-started guide).

    Claude Code. Run this in a terminal. Everything after -- is the command that starts the proxy:

    claude mcp add danske-bank-apis --env MCP_SERVER_API_KEY=<your-api-key> -- npx -y @danskebank/mcp-api-proxy@latest

    Other clients, including Claude Desktop and HTTP mode, are covered in the getting-started guide.

  3. Start the proxy and check the tools. In VS Code, save the file, run MCP: List Servers, and start or restart your proxy entry; in Claude Code, run claude mcp list. Start an agent session and check that get_filters, search_apis, and call_endpoint appear for the server. If only call_endpoint appears, the catalog connection failed - check the API key and the server output. The first start can take a little longer while npx downloads the package.

The proxy connects to the production service endpoints, including the Mock Service and Sandbox; it does not select which API data tier to call. Set tier explicitly to mock, sandbox, or live when calling call_endpoint.

To call sandbox or production endpoints, complete Premium API onboarding, then add your Client ID, client certificate, and matching private key to the env block. Private keys are encrypted by default, so the key's passphrase is needed too:

"env": {
  "MCP_SERVER_API_KEY": "<your-api-key>",
  "CLIENT_ID": "your-client-id",
  "CLIENT_CERT_PEM": "/absolute/path/to/client-cert.pem",
  "CLIENT_KEY_PEM": "/absolute/path/to/client-key.pem",
  "CLIENT_KEY_PASSPHRASE": "your-key-passphrase"
}

Follow the public getting-started guide for the private settings-file option, other clients, and troubleshooting. Keep certificates and keys outside your project, and never commit secrets.

Production is GET-only. When live credentials are fully configured, calls that omit tier default to live. Use tier: mock or tier: sandbox explicitly when you want test data.

Your responsibility. The Proxy lets your AI agent call Premium API endpoints directly. Danske Bank does not review, approve, or monitor the actions your agent takes through the Proxy - you are responsible for reviewing what your agent does before it executes, and for any consequences of its API calls.

For AI Agents helping with setup

If you are an AI assistant helping a user connect to the MCP Service, fetch the package documentation directly rather than guessing at configuration:

  • Setup guide: https://raw.githubusercontent.com/danskebank/mcp-api-proxy/main/GETTING-STARTED.md
  • Full reference: https://raw.githubusercontent.com/danskebank/mcp-api-proxy/main/README.md

These contain the authoritative environment variables, client configuration examples, and troubleshooting steps. Do not invent configuration values.

This page and the linked documentation are intended for setup guidance. Anything beyond configuration - calling live endpoints, initiating transactions - is governed by the responsibility note above.

To be aware of

  1. Call get_filters to discover valid filter values.
  2. Call search_apis using filter values returned by get_filters. Use keyword only to match on API name, not for domain or type filtering.
  3. Call get_api_info with the integrationKey returned by search_apis to see available versions and environments.
  4. Call get_endpoint_details or get_business_description using an environment value from get_api_info - don't hard-code an environment.

Never fabricate an integrationKey - always obtain it from search_apis first.

Getting auth guidance

Ask your agent to call get_auth_guide, or ask a question like:

  • "How do I authenticate to the Premium APIs?"
  • "Show me the security setup for the Payment Initiation API."

This returns the same guidance as Get started and Endpoints, formatted for your agent to read directly.

Authentication and rate limits

  • MCP Server: an API key is required to connect to https://mcp.danskebank.com/mcp. Request a key using your email address, accept the MCP service disclaimer, and follow the email link. Your key is shown only once, so save it securely. No District agreement or Premium API onboarding is needed for this key, and it does not grant access to customer data.
  • Sending your key: use the X-API-Key header for a direct MCP Server connection, or MCP_SERVER_API_KEY for the local proxy. Treat the key as a password - don't commit it to source control, paste it into chat, or put it in a shared config file; keep it in a personal configuration file outside your projects or, for the local proxy, in a private settings file instead.
  • Auth rejections look different from a typical HTTP error. If the X-API-Key header is missing or invalid, the server returns a JSON-RPC error with HTTP 200 OK rather than an HTTP 401 - this is deliberate, to stop MCP clients from attempting OAuth dynamic client registration. As a result, the failure shows up in your chat or MCP output panel rather than as a network-level error.
  • Rate limits: requests are rate limited per API key to keep the service responsive for everyone. If you're throttled, you'll receive an HTTP 429 response - wait a moment and retry.

See also