# Find your app identifiers

When you register an app in WarpLink, the form asks for a few identifiers. Each one has a short job: Apple and Google use them to check that a link is allowed to open your app. This page shows where to find every value, in the order the form asks for it.

| Platform | Value | Needed for | Jump to |
|----------|-------|------------|---------|
| iOS | Bundle ID | Universal Links | [Bundle ID](#bundle-id) |
| iOS | Team ID | Universal Links | [Team ID](#team-id) |
| iOS | App Store URL | Sending people without your app to the App Store, and your App Store ID | [App Store URL](#app-store-url) |
| Android | Package name | App Links | [Package name](#package-name) |
| Android | SHA256 fingerprint | App Links | [SHA256 fingerprint](#sha256) |

You need the iOS values to open your iOS app from a link, and the Android values to open your Android app. Add one platform now and the other later if you ship on only one at first.

## Find your iOS bundle ID [#bundle-id]

The bundle ID is the reverse-domain name that identifies your iOS app, such as `com.example.myapp`.

**In Xcode:**

1. Select your project in the Project navigator, then select the app target.
2. Open the **General** tab.
3. Read **Bundle Identifier** under **Identity**.

**Without Xcode:** open [App Store Connect](https://appstoreconnect.apple.com), select your app, go to **App Information**, and read **Bundle ID** under **General Information**. The **Identifiers** list at [developer.apple.com](https://developer.apple.com/account) shows the same value.

Use the bundle ID of the main app target that ships to the App Store. App extensions and test targets have their own bundle IDs, which do not open your app.

## Find your Apple Team ID [#team-id]

The Team ID is a 10-character code of letters and digits, such as `ABCDE12345`. Apple pairs it with your bundle ID to tell iOS which app a Universal Link may open.

**On the Apple Developer site:**

1. Sign in at [developer.apple.com/account](https://developer.apple.com/account).
2. Open **Membership details**.
3. Copy **Team ID**.

**In Xcode:** the Team ID is stored in the `DEVELOPMENT_TEAM` build setting. Xcode shows your team by name, so open `project.pbxproj` and search for `DEVELOPMENT_TEAM = ` to read the code.

Your Team ID is not your Apple ID email address, and it is not a secret. Apple shows it to every member of your team.

## Find your App Store URL [#app-store-url]

This is the public address of your app's App Store page. WarpLink sends people who tap a link without your app installed to this page.

1. On an iPhone, open your app's page in the App Store.
2. Tap **Share**, then **Copy Link**.
3. Paste the URL into the **App Store URL** field.

The link looks like `https://apps.apple.com/app/id123456789`. The number after `id` is your App Store ID, and WarpLink reads it from the URL. You do not enter it separately. In App Store Connect, the same number appears as **Apple ID** under **App Information**.

The store URL is optional. If your app is not live yet, leave it empty and add it when the app is published.

## Find your Android package name [#package-name]

The package name is the unique ID of your Android app, such as `com.example.myapp`.

**In Android Studio:** open `app/build.gradle` or `app/build.gradle.kts` and read `applicationId` inside `defaultConfig`.

**In Google Play Console:** open your app. The package name sits under the app name on the dashboard.

Use `applicationId`, not `namespace`. The `namespace` value only names the code package and can differ from the ID your app ships with. If your debug build adds an `applicationIdSuffix` such as `.debug`, register the release package name, which has no suffix.

Your Google Play URL contains the package name: `https://play.google.com/store/apps/details?id=com.example.myapp`. Copy the full URL from your Play Store listing for the **Play Store URL** field. It is optional, like the App Store URL.

## Get your Android SHA256 fingerprint [#sha256]

The SHA256 fingerprint identifies the certificate that signs your app. Android compares it with the fingerprint in your link domain's `assetlinks.json` before it opens App Links in your app. It is 32 pairs of hex characters separated by colons:

```text
14:6D:E9:83:C5:73:06:50:D8:EE:B9:95:2F:34:FC:64:16:A0:83:42:E6:1D:BE:A8:8A:04:96:B2:3F:CF:44:E5
```

Where you find it depends on who signs the build your users install.

Apps published as an Android App Bundle use Play App Signing. Google re-signs your app with its own key, so the fingerprint that matters is the one in Play Console, not the one on your computer.

1. Open [Google Play Console](https://play.google.com/console) and select your app.
2. Go to **Test and release**, then **App integrity**.
3. Open the **App signing** tab.
4. Copy **SHA-256 certificate fingerprint** under **App signing key certificate**.

The same tab lists an **Upload key certificate**. Add that fingerprint as well if you install builds signed with your upload key, such as an internal build you sideload.

Builds you sign yourself, such as debug builds and release builds installed outside Google Play, use your local keystore.

Read the fingerprint with `keytool`:

```bash
keytool -list -v -keystore ~/.android/debug.keystore \
    -alias androiddebugkey -storepass android
```

That command reads the debug keystore. For a release keystore, use your own file and alias, and enter the password when prompted:

```bash
keytool -list -v -keystore your-release-key.keystore -alias your-alias
```

Copy the value on the `SHA256:` line. Or let Gradle list every variant for you:

```bash
./gradlew signingReport
```

A fingerprint from your local release keystore does not match an app installed from Google Play when Play App Signing is on. Add the App signing key certificate from Play Console for installs from the store.

You can register more than one fingerprint. Add the Play App Signing fingerprint for store installs, plus your debug or release fingerprint for builds you test on your own devices. WarpLink uppercases the value for you.

## Add the values to WarpLink

1. In the dashboard, open **Apps** and choose **Register app**, or open an existing app and go to its **Settings**.
2. Turn on iOS, Android, or both.
3. Paste each value into its field. For iOS, paste the App Store URL. WarpLink reads the App Store ID from it.

Using the API instead? Send the App Store address in `ios_app_store_url` and the Google Play address in `android_play_store_url`. The other fields are `ios_bundle_id`, `ios_team_id`, `android_package_name`, and `android_sha256_fingerprints`. `ios_app_store_id` is a separate field for the number only, such as `123456789`, never the full URL. See the [Apps API](https://warplink.app/docs/api/apps).

After you save, WarpLink publishes the Apple and Android verification files for your app's link address. To read them for any domain, use our [deep link checker](https://warplink.app/tools/deep-link-checker). Next, add the matching setup to your app in the [iOS SDK guide](https://warplink.app/docs/sdks/ios#configure-associated-domains-for-universal-links) or the [Android SDK guide](https://warplink.app/docs/sdks/android#add-app-links-intent-filter).

## Related

- [AASA file generator](https://warplink.app/tools/aasa-generator) and [assetlinks.json generator](https://warplink.app/tools/assetlinks-generator): build the Apple and Android files from the identifiers on this page, for a domain you host yourself
- [Deep linking](https://warplink.app/docs/concepts/deep-linking): how Universal Links and App Links route people into your app
- [Glossary](https://warplink.app/docs/glossary): plain definitions of Universal Link, App Link, and other terms
