BlogAI tools

A deep links MCP server in your AI coding tool: what it can check, create and change

· 8 min read · By the Strait team

What a deep links MCP server does in Claude Code, Cursor or Codex: App Links checks, tap traces, bulk links and webhooks, and the rules that keep it safe.

You are in your editor, the app builds, and someone in the team chat says the new campaign link opens the browser instead of the app. Fixing it usually means leaving the editor: open the link dashboard, find the link, open a checker for assetlinks.json, open another for Apple's file, then come back and guess which line of your manifest is wrong.

An MCP server for deep links moves those checks into the AI tool you already have open. You ask "why does this link open the browser on Instagram?", and the assistant calls the link service, reads the real answers and tells you what to change. This post covers what such a server is, the jobs it does well, the jobs it should never do on its own, and how to set one up in about five minutes.

What an MCP server is, in one paragraph

MCP, the Model Context Protocol, is an open standard for connecting AI tools to other systems. A server offers a list of tools, each with a name, a description and the inputs it takes. The AI tool (Claude Code, Claude Desktop, Cursor, Codex and others) reads that list and decides when to call a tool while it works on your request. A local server is a small program that runs on your own computer, started by the AI tool and spoken to over standard input and output. A hosted server runs on the vendor's side and you sign in to it. Both give the assistant the same kind of thing: real answers from a real system instead of a guess from memory.

Most deep-link bugs are not code bugs. They are mismatches between three things that live in three places:

  1. The association files the link domain serves: /.well-known/assetlinks.json for Android App Links and apple-app-site-association for iPhone Universal Links.
  2. The app's own settings: the package name and signing certificate fingerprints on Android, the Team ID and bundle ID on iPhone, and the domains the app claims.
  3. The link service's decision for each tap, which depends on the phone, the browser and the app the link was tapped inside (WhatsApp, Instagram and Facebook all open links in their own browsers).

An assistant that can only read your repository sees part of the second one. It can't see what the link domain serves today, and it can't see what the link service would do for an Instagram tap on Android. That is exactly where it starts guessing. A deep links MCP server gives it the other two.

Five jobs it does well

1. Check the association files, with a fix for each problem

The most common reason a link opens the browser is a file that is missing, served with the wrong content type, or listing the wrong certificate. A check tool fetches both files from the domain and returns each finding with a severity and a fix, for example a file served as a web page instead of JSON, or an app missing from the list. The assistant can then compare that with your build.gradle or Xcode settings, which it can read, and point at the exact line.

This check needs no account at all, because the files are public. In the Strait server it is check_app_links, and the same check runs on the web as the App Links checker.

"It works on my phone" is the classic deep-link trap: you tested in Chrome, and your users tap in WhatsApp. A trace tool runs the link through the common places in turn (Android Chrome, the WhatsApp, Instagram and Facebook in-app browsers, iPhone Safari, iPad, a computer, a preview bot) and returns one row for each: what the link service decided, where the tap was sent, and why. Nothing is recorded or billed, because these are simulated taps.

A table like that ends most arguments about whether a link "works". If the Instagram row says the tap went to an escape page that opens the app, and your report says it didn't, the problem is on the phone, not in the link.

Campaigns arrive as spreadsheets. An assistant with a batch tool can read the CSV in your project, build one link per row with the right path, title and tags, and send them in one call instead of five hundred. Strait's batch_create_links takes up to 500 links per call and is safe to run twice: a slug that already exists comes back as its own error for that row, and the rest still go through.

4. Answer analytics questions in plain words

"Which channel brought the most installs last month?" is a question people ask in a sentence, not a dashboard filter. An analytics tool returns taps, app opens, installs, conversions and revenue for a date range, grouped by day, channel, link or platform, using the same definitions as the dashboard. The assistant does the reading and answers in a sentence, with the numbers it used.

5. Debug webhooks without a second terminal

When a webhook stops firing, you want three things in order: the last few deliveries and their HTTP status, a test event to see whether your receiver answers at all, and a resend of the deliveries that failed. Version 0.2.0 of the Strait server has a tool for each of those: list_webhook_deliveries, test_webhook and redeliver_webhook_delivery.

What it should never do on its own

Giving an AI tool write access to the links your customers tap needs a few hard rules. These are the ones we built in, and they are worth asking any vendor's server about.

The secret key stays on your computer. A link service has two kinds of key. The publishable key ships inside your app and can only resolve links and report opens. The secret key can create and change links, so it belongs in the AI tool's settings on your machine and nowhere else: not in the app, not in a website, not in a committed config file. Make a separate secret key for your AI tools, so you can revoke it without touching your servers. The Strait server refuses to start with a publishable key, and hides anything that looks like a secret key in its answers.

Changes to live links ask first. Changing a link's destination changes where every future tap goes. In the Strait server, update_link, deactivate_link and redeliver_webhook_delivery return a preview of what they would do and act only when called again with an explicit confirm. In practice the assistant shows you the old and new values and waits for your yes.

There is no delete tool. Pausing a link is the furthest a tool can go. You can turn it back on from the dashboard, the API or the MCP server, and the MCP tool asks first, as it does for pausing.

Read before you trust. Everything the server returns is data: link titles, destinations, webhook answers. A link title could, in theory, contain text written to steer an assistant. Keep the confirm prompts on, read what the assistant proposes before you approve a write, and use a key that only reaches the workspace you mean.

A typical session

Here is the shape of a real debugging run, written out step by step. You type: "My links on hilltop.strait.link open the browser on Android. Fix it."

  1. The assistant calls check_app_links for hilltop.strait.link. The file is there, but it lists only one SHA-256 fingerprint.
  2. It runs keytool on your debug keystore and finds that fingerprint is the debug one. Your users install the Play build, which Google signs with a different certificate. It tells you where to copy the Play App Signing SHA-256 from (Play Console, App integrity) and which box to paste it into in the dashboard.
  3. After you paste it, it runs the check again. Both fingerprints are listed now.
  4. It calls trace_tap on one of your links. The Android rows now send the tap to the app; the Instagram row says the tap goes through an escape page first, which is expected for in-app browsers.
  5. It suggests one last test on a real phone: tap the link from a chat, after reinstalling the app so Android verifies the domain again.

Each step used a real answer from a tool, not a guess from memory.

Set it up

You need Node.js 20 or newer and a Strait secret key from Dashboard → Settings → Keys. In Claude Code it is one command:

Terminal
claude mcp add strait --env STRAIT_SECRET_KEY=st_live_…your_key -- npx -y @straitlink/mcp

Cursor, Claude Desktop and Codex each take a short config block instead. The MCP server docs have all four, the full list of tools with which ones write, and the three errors people hit most. If you want the setup file for your app written for you instead, strait init does that from the terminal.

What isn't there yet

The Strait server now also runs hosted, at https://strait.link/mcp: your AI tool sends the secret key in a header, so there is nothing to install. Signing in with OAuth, with no key to paste, isn't available yet. And it is a deep-link server, not an attribution platform: it knows your links, taps, opens and events, not ad-network spend.

Other deep-link vendors ship MCP servers too, some of them hosted. Whichever you use, the questions above are the ones to ask: where the key lives, which tools write, and whether a change to a live link waits for you.

Sources and how we checked

  • Model Context Protocol, Introduction and the specification: what servers, tools and the stdio transport are. Read on 23 October 2026.
  • Anthropic, Connect Claude Code to tools via MCP: the claude mcp add command and the --env option. Read on 23 October 2026.
  • Android Developers, Verify Android App Links, and Apple, Supporting associated domains: the two association files.
  • Strait's tool list, key rules and confirm behaviour are from @straitlink/mcp 0.2.0 and 0.2.1 as published on npm, started from an empty folder with npx on 23 October 2026 and listed over stdio (16 tools). The debugging session above is written from the tools' real behaviour; the workspace and findings are an example.