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

> Connect Claude Code to the WarpLink MCP server and let it register your app, add the SDK, create a link, and run verify_setup. Commands and outputs inside.

_Last updated: 2026-10-21_

> **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](https://code.claude.com/docs), 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:

```bash
/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:

```bash
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:

```bash
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](https://warplink.app/docs/ai-access) has the configuration for each. [WarpLink for AI agents](https://warplink.app/ai) gives the overview.

## Step 2: Give the agent the rules

Paste the WarpLink block from the [AI agents guide](https://warplink.app/docs/ai-agents) 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:

```text
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:

```json
{
  "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:

```json
{ "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:

```json
{
  "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:

```json
{
  "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`:

```json
{
  "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](https://warplink.app/blog/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](https://warplink.app/blog/agent-ready-api-design), and the endpoint is in [Agent sign-up](https://warplink.app/docs/api/agent-signup).

## 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](https://warplink.app/docs/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](https://warplink.app/docs/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](https://warplink.app/blog/universal-links-not-opening), the [AASA file checks](https://warplink.app/blog/apple-app-site-association-not-working), or [Android App Links autoVerify](https://warplink.app/blog/android-app-links-autoverify-failed). Platform detail is in the [iOS](https://warplink.app/docs/sdks/ios/deep-links) and [Android](https://warplink.app/docs/sdks/android/deep-links) deep link docs, and the [deep linking guide](https://warplink.app/blog/deep-linking-guide) covers the concepts.

To compare WarpLink with other deep linking MCP servers, read [the best deep linking and attribution MCP servers](https://warplink.app/blog/best-deep-linking-attribution-mcp-servers). The free plan covers 10,000 clicks a month, and [pricing](https://warplink.app/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](https://warplink.app/docs/ai-access) 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](https://warplink.app/docs/ai-agents)
- [WarpLink for AI agents](https://warplink.app/ai)
- [What makes an API safe for AI agents](https://warplink.app/blog/agent-ready-api-design)
- [How to test deep links on iOS and Android](https://warplink.app/blog/how-to-test-deep-links)
- [The best deep linking and attribution MCP servers](https://warplink.app/blog/best-deep-linking-attribution-mcp-servers)

[Create a free account](https://dash.warplink.app/auth/signup) and connect your coding agent.