Set Up Deep Linking With Claude Code: From Empty Project to Verified Link

TL;DR: A coding agent connects to the WarpLink MCP server, registers your app, creates an SDK key tied to it, gets the exact SDK and link-domain steps from get_sdk_setup, creates a link, and calls verify_setup until only the steps that need a person remain. This guide shows the commands, what each call returns, and the short list that stays with you.

WarpLink is link infrastructure for mobile teams: deep linking, install attribution, and real-time analytics in one SDK. You can create your first link in about 5 minutes, and teams integrate the SDK in under 30 minutes. This guide shows how to hand that work to Claude Code, from an empty project to a link that verify_setup has checked.

What you need

• A mobile project in iOS, Android, React Native, or Flutter.
• Claude Code, or another MCP client such as Cursor or Windsurf.
• The iOS bundle ID and team ID, the Android package name and SHA256 certificate hashes, or both for a cross-platform app. get_sdk_setup lists any app field the platform still needs.

Step 1: Connect the MCP server

The WarpLink MCP server is at https://api.warplink.app/mcp. It uses Streamable HTTP, is listed in Claude's Connectors Directory, exposes 36 tools, and is free on every plan.

In Claude Code, the quickest path is the agent kit, a plugin that holds the server entry and the warplink-setup skill, which follows the steps below:

/plugin marketplace add WarpLinkApp/warplink-agent-kit
/plugin install warplink@warplink

Then run /mcp and choose Authenticate. A browser window opens for a one-time sign-in and consent screen. There is no key to paste.

Without the plugin, add the server by hand instead. Use one path or the other, so you do not end up with two entries:

claude mcp add --transport http warplink https://api.warplink.app/mcp

Then run /mcp and choose Authenticate. For CI or other non-interactive use, add the server with an API key as a header in place of the plugin. Use an API key here, never an SDK key:

claude mcp add --transport http warplink https://api.warplink.app/mcp \
  --header "Authorization: Bearer wl_live_YOUR_API_KEY"

The server shares the REST API limit of 60 requests a minute per credential. Cursor, Windsurf, and Claude Desktop use the same URL, and AI access has the configuration for each. WarpLink for AI agents gives the overview.

Step 2: Give the agent the rules

Paste the WarpLink block from the AI agents guide into your project's AGENTS.md, or into CLAUDE.md for Claude Code. The block tells any agent the order of the tool calls and the rules that keep keys out of source control: use the exact link host, never a wildcard, and apply details.fix before retrying.

Step 3: Ask for the setup

Send one prompt:

Set up WarpLink in this app and check that it works.

The MCP server also offers a ready-made prompt, setup_deep_linking, and a read-only resource at warplink://apps/{app_id}/setup, so a client with a prompt picker can start the same flow from its menu.

What the agent does

The agent makes the calls below, in order. The excerpts are trimmed, and the names and IDs are example values.

list_apps and create_app

The agent calls list_apps. If the project has no app, it calls create_app with the platform identifiers. It passes dry_run: true first, which runs every check a real call runs and saves nothing:

{
  "name": "Acme",
  "ios_bundle_id": "com.example.acme",
  "ios_team_id": "ABCDE12345",
  "dry_run": true
}

The answer has the shape { "dry_run": true, "result": ... }. When it looks right, the agent repeats the call without dry_run. Every app gets its own link host, {handle}.aplnk.to, with WarpLink-hosted apple-app-site-association and assetlinks.json files, so there is no file for you to host.

create_key

Next the agent creates an SDK key tied to the app:

{ "name": "iOS app", "type": "sdk", "app_id": "APP_ID" }

An SDK key made over OAuth belongs to one app, has the fixed SDK scopes, works only on the SDK routes, and never expires. The raw key is shown once. The agent puts it in the app's own config or secret store and uses the YOUR_SDK_KEY placeholder in anything that gets committed. list_keys shows created_via, so you can see which keys an agent made.

get_sdk_setup

The agent calls get_sdk_setup with the app_id and the platform: ios, android, react-native, or flutter. The answer holds everything the project needs:

{
  "platform": "ios",
  "sdk_version": "1.1.1",
  "install": { "...": "the install step for the current SDK" },
  "configure": { "...": "the configure snippet with YOUR_SDK_KEY" },
  "link_domains": { "sdk_host": "acme.aplnk.to", "hosts": ["acme.aplnk.to"] },
  "ios": { "associated_domains": ["applinks:acme.aplnk.to"] },
  "test_address": "https://acme.aplnk.to/test"
}

On Android the answer carries the intent filter in place of the Associated Domains lines. The agent installs the SDK at the version the call returns, adds the configure snippet, and writes the exact host lines into the project. All four SDKs are at 1.1.1, MIT licensed, with zero third-party dependencies. The same data is available over REST as GET /v1/apps/{id}/sdk-setup.

create_link

The agent creates a first link for the app and sends an idempotency_key, so a retry after a dropped connection cannot create a second link:

{
  "app_id": "APP_ID",
  "destination_url": "https://example.com/welcome",
  "idempotency_key": "6b0c2f4e-9d1a-4c35-8e7b-3a5d1f9c0b42"
}

A replay with the same key returns the first result. Keys last 24 hours.

verify_setup

Finally the agent calls verify_setup with the app_id. It returns ready, a list of checks, and a needs_human list. Each check has one of five statuses: pass, fail, warn, needs_human, or skipped. Each failing check carries a fix:

{
  "ready": true,
  "checks": [
    { "id": "well_known_files", "status": "pass", "detail": "..." },
    { "id": "sdk_connected", "status": "needs_human", "detail": "...", "fix": "..." }
  ],
  "needs_human": [{ "id": "sdk_connected", "detail": "...", "fix": "..." }]
}

The agent applies each fix, calls verify_setup again, and stops when only needs_human checks remain. The same check is available as GET /v1/apps/{id}/setup-check.

The hand-off: what stays with you

Some steps need a person, and the agent tells you which. The needs_human list holds:

• A tap on a link on a real device.
• The first click arriving.
• The SDK connecting from a real device, which only a running app can do.
• Confirming the Associated Domains capability and the manifest lines in your project.
• Claiming the workspace, if the agent signed up for you.

Each entry names the exact step. When the list is the only thing left, the rest happens on your phone and in your project.

Check the host

Open https://<app host>/test in a browser, where <app host> is the app's own host, such as acme.aplnk.to. The page confirms the host serves your app's link files. For testing on a device, see how to test deep links.

No account yet?

The agent can start before you have a WarpLink account. It calls POST /v1/agent/signup with your email address and its own name. WarpLink creates a Free workspace, emails you the claim link, and returns an MCP token. Links stay paused until you claim the workspace. The design is covered in what makes an API safe for AI agents, and the endpoint is in Agent sign-up.

The same flow over REST

A script or CI job can run the same steps without MCP: GET /v1/apps/{id}/sdk-setup returns the setup steps and GET /v1/apps/{id}/setup-check returns the checks. Both take an API key. See Quickstart for the manual setup.

Troubleshooting

• 403 SDK_KEY_ROUTE_FORBIDDEN: an SDK key reached the MCP server or a REST route that is not an SDK route. Connect with the browser sign-in or an API key, and keep the SDK key in the app.
• A failed call: when we know the remedy, the error carries details.fix, and the MCP server also puts Fix: ... in the error text. Apply the fix, then retry. Errors lists every code.
• Links do not open the app: the agent writes the exact host from get_sdk_setup, never a wildcard. If a link still opens the browser, work through Universal Links not opening, the AASA file checks, or Android App Links autoVerify. Platform detail is in the iOS and Android deep link docs, and the deep linking guide covers the concepts.

To compare WarpLink with other deep linking MCP servers, read the best deep linking and attribution MCP servers. The free plan covers 10,000 clicks a month, and pricing lists the paid plans.

Frequently Asked Questions

Can Claude Code set up deep linking in my app?

Yes. Claude Code connects to the WarpLink MCP server, registers your app, creates an SDK key tied to it, reads the exact SDK and link-domain steps from get_sdk_setup, creates a link, and calls verify_setup until only the steps that need a person remain, such as a tap on a real device. It works for iOS, Android, React Native, and Flutter projects.

How do I connect Claude Code to the WarpLink MCP server?

Run claude mcp add --transport http warplink https://api.warplink.app/mcp, then run /mcp in Claude Code and choose Authenticate to finish the one-time browser sign-in. For CI or other non-interactive use, send an API key as an Authorization header with the value Bearer wl_live_YOUR_API_KEY instead.

Does the agent need my API key or SDK key?

Not for the browser sign-in, which needs no key at all. The agent then creates an SDK key tied to your app with create_key and writes it into the app's own config or secret store, never into chat or a committed file. An SDK key goes only in the mobile app. An API key goes only to the MCP server and the REST API, which refuses SDK keys with 403 SDK_KEY_ROUTE_FORBIDDEN.

What does verify_setup check, and what is left for me to do?

verify_setup checks the app configuration, the hosted link files, custom domain serving, the SDK key, whether the SDK has connected, the SDK version, the test link, and the first click. Each check returns pass, fail, warn, needs_human, or skipped, and each failing check carries a fix. What is left for you is the needs_human list: a tap on a device, the first click, the SDK connecting from a real device, confirming the Associated Domains and manifest lines in your project, and claiming the workspace if the agent signed up for you.

Does this work in Cursor or Windsurf?

Yes. Any client that speaks MCP over Streamable HTTP can follow the same flow. Cursor and Windsurf connect with the server URL and the browser sign-in, or with an API key header. The AI access docs list the configuration for each client.

Can the agent start before I have a WarpLink account?

Yes. The agent calls POST /v1/agent/signup with your email address and its own name. WarpLink creates a Free workspace, emails you a claim link, and returns an MCP token. The workspace holds 1 app and 10 links until you claim it, and its links stay paused until then.

Does the MCP server cost extra?

No. The MCP server is free on every plan, including Free. It shares the REST API limit of 60 requests a minute per credential. Your plan's limits on apps, links, members, and custom domains still apply to what the agent creates.

Related Guides

• AI agents guide
• WarpLink for AI agents
• What makes an API safe for AI agents
• How to test deep links on iOS and Android
• The best deep linking and attribution MCP servers

Create a free account and connect your coding agent.