Appearance
Capacitor SDK
Linkrunner MMP SDK for Capacitor: install attribution, deferred deep linking, in-app events and revenue tracking.
RequiredInstallationInitializationUser Identification
OptionalSDK Signing ParametersSetting the Customer User IDHandle DeeplinkGetting Attribution DataSetting User DataSetting CleverTap IDMeta Anonymous IDRevenue TrackingTracking Custom EventsEnhanced Privacy ControlsPrivacy modeUninstall Tracking
Prefer to let your AI coding agent do this? Install the Linkrunner skill and Claude Code, Cursor, GitHub Copilot, or Windsurf will wire up the SDK and deep links for you:
bash
npx @linkrunner/skills add capacitorThen ask your agent to "integrate Linkrunner". See Linkrunner Agent Skills.
Installation
Step 1: Install the Package
bash
# Using npm
npm install capacitor-linkrunner
# Using yarn
yarn add capacitor-linkrunnerStep 2: Sync Native Projects
bash
npx cap syncStep 3: iOS Configuration
If you're developing for iOS, follow these additional steps:
- Install pods for the package:
bash
cd ios/App && pod install- Add the following code to your
Info.plistfile:
xml
<key>NSUserTrackingUsageDescription</key>
<string>This identifier will be used to deliver personalized ads and improve your app experience.</string>Step 4: SKAdNetwork Configuration
To enable SKAdNetwork postback copies to be sent to Linkrunner, add the following keys to your Info.plist file:
xml
<key>NSAdvertisingAttributionReportEndpoint</key>
<string>https://linkrunner-skan.com</string>
<key>AttributionCopyEndpoint</key>
<string>https://linkrunner-skan.com</string>For complete SKAdNetwork integration details, see the SKAdNetwork Integration Guide.
Google Integrated Conversion Measurement (ICM) is not available in the Capacitor plugin yet. capacitor-linkrunner 2.1.1 pins LinkrunnerKit 4.0.x and io.linkrunner:android-sdk:4.0.1, and ICM needs 4.1.0 on both. If you run Google App Campaigns for your iOS app, contact support@linkrunner.io. See Google ICM for what it does.
Step 5: Android Backup Configuration
For Android apps, the SDK provides backup rules to exclude Shared Preferences data from backup. This prevents the retention of the Linkrunner install ID during reinstallation, ensuring accurate detection of new installs and re-installs.
For detailed backup configuration instructions, please refer to the Android SDK Backup Configuration.
Step 6: Android Kotlin Configuration
The Capacitor Linkrunner SDK requires the Kotlin Gradle plugin. Add the following to your root build.gradle file under dependencies:
groovy
buildscript {
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}For example, with Kotlin version 1.9.22:
groovy
buildscript {
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.22"
}
}Initialization (Required)
To initialize the Linkrunner SDK, add this code to your app's initialization:
You can find your project token here.
Note: The initialization method doesn't return any value. To get attribution data and deeplink information, use the getAttributionData method.
typescript
import linkrunner from "capacitor-linkrunner";
// Inside your app initialization
const init = async () => {
await linkrunner.init(
"YOUR_PROJECT_TOKEN",
"YOUR_SECRET_KEY", // Optional: Required for SDK signing
"YOUR_KEY_ID", // Optional: Required for SDK signing
false, // Optional: Set to true to disable IDFA collection for iOS devices (defaults to false)
true // Optional: Enable debug mode for development (defaults to false)
);
console.log("Linkrunner initialized");
};
// Call init when app starts
init();SDK Signing Parameters (Optional)
For enhanced security, the Linkrunner SDK accepts the following signing parameters during initialization:
secretKey: A unique secret key used for request signing and authenticationkeyId: A unique identifier for the key pair used in the signing process
You can find your project token, secret key, and key ID here.
Setting the Customer User ID
Use setCustomerUserId to attach your own user identifier to the device right after init. Once set, the identifier is stored securely on-device and automatically included in every event you track, so you never have to pass it on each trackEvent call.
Call it as early as the user's ID is available. This guarantees every event carries a user_id from the very first event, and is especially useful for existing users who were already onboarded before this feature shipped.
Available from Capacitor SDK v1.3.0.
Best practice: set the Customer User ID as early as possible. The user_id is only attached to events tracked after it's set, and is not applied retroactively. Use a stable, unique identifier from your own system (for example your internal user ID or a UUID) rather than an email address or other PII.
typescript
import linkrunner from "capacitor-linkrunner";
try {
await linkrunner.setCustomerUserId("f47ac10b-58cc-4372-a567-0e02b2c3d479"); // Your unique customer user ID (e.g. a UUID)
console.log("Customer user id set");
} catch (error) {
console.error("Error setting customer user id:", error);
}The identifier is stored securely on-device and persists across app restarts. Calling setCustomerUserId again with a different identifier updates the stored value; passing the same identifier is a no-op. signup(), and setUserData() called with an id, also update it.
User Identification (Required)
Call the signup method as soon as the user is identified, whether through signup or login. This is the moment Linkrunner ties the install (and any future events) to a user identifier.
It is strongly recommended to use the integrated platform's identify function to set a persistent user_id once it becomes available (typically after signup or login).
- Mixpanel - ID Management & User Identification
- PostHog - How User Identification Works
- Amplitude - Identify Users Documentation
If the platform's identifier function is not called, you must provide a user identifier for Mixpanel, PostHog, and Amplitude integration.
- mixpanel_distinct_id for Mixpanel
- posthog_distinct_id for PostHog
- amplitude_device_id for Amplitude
typescript
import linkrunner from "capacitor-linkrunner";
const onSignup = async () => {
try {
await linkrunner.signup({
user_data: {
id: "123", // Required: User ID
name: "John Doe", // Optional
phone: "9876543210", // Optional
email: "user@example.com", // Optional
// These properties are used to track reinstalls
user_created_at: "2024-01-01T00:00:00Z", // Optional
is_first_time_user: true, // Optional
mixpanel_distinct_id: "mixpanel_distinct_id", // Optional - Mixpanel Distinct ID
amplitude_device_id: "amplitude_device_id", // Optional - Amplitude User ID
posthog_distinct_id: "posthog_distinct_id", // Optional - PostHog Distinct ID
},
data: {}, // Optional: Any additional data
});
console.log("Signup successful");
} catch (error) {
console.error("Error during signup:", error);
}
};Handle Deeplink
To enable remarketing and reattribution, you need to capture deep links and pass them to the Linkrunner SDK. This allows Linkrunner to detect returning users who open the app via a deep link.
typescript
import { App } from '@capacitor/app';
import linkrunner from 'capacitor-linkrunner';
// Init SDK first
await linkrunner.init('your_project_token');
// Cold start — app was launched by a deeplink
const launchUrl = await App.getLaunchUrl();
if (launchUrl?.url) {
linkrunner.handleDeeplink(launchUrl.url);
}
// Warm start — app was in background, deeplink brought it to foreground
App.addListener('appUrlOpen', ({ url }) => {
linkrunner.handleDeeplink(url);
});Linkrunner sends the updated deeplink back after processing. For Linkrunner campaign links, use the returned deeplink as the resolved destination instead of the original tracking URL.
json
{
"deeplink": "https://app.yourdomain.com/product/123"
}Getting Attribution Data
To get attribution data and deeplink information for the current installation, use the getAttributionData function:
typescript
import linkrunner from "capacitor-linkrunner";
const getAttributionInfo = async () => {
try {
const attributionData = await linkrunner.getAttributionData();
console.log("Attribution data:", attributionData);
} catch (error) {
console.error("Error getting attribution data:", error);
}
};The getAttributionData function returns:
typescript
{
deeplink: string | null;
campaignData: {
id: string;
name: string;
type: string; // "ORGANIC" | "INORGANIC"
adNetwork: string | null; // "META" | "GOOGLE" | null
installedAt: string;
storeClickAt: string | null;
groupName: string;
assetName: string;
assetGroupName: string;
adNetworkCampaignId?: string; // Ad network campaign ID
adSetId?: string; // Ad set ID
adSetName?: string; // Ad set name
adCreativeId?: string; // Ad creative ID
adCreativeName?: string; // Ad creative name
};
gaid?: string | null; // Android only
idfa?: string | null; // iOS only, null when ATT is not authorized
}gaid is set on Android and idfa on iOS. Each one is null when it is not available, for example on the other platform, when the user has not allowed tracking (ATT), or when limited ad tracking is on. Requires capacitor-linkrunner 2.2.0 or later.
Example response:
json
{
"deeplink": "https://app.yourdomain.com/product/123",
"campaignData": {
"id": "camp_123",
"name": "Summer Sale 2024",
"type": "INORGANIC",
"adNetwork": "META",
"installedAt": "2024-03-20T10:30:00Z",
"storeClickAt": "2024-03-20T10:29:45Z",
"groupName": "Summer Sale Group",
"assetName": "Banner Ad 1",
"assetGroupName": "Product Catalog",
"adNetworkCampaignId": "120214682829390250",
"adSetId": "120214682829640250",
"adSetName": "Productivity",
"adCreativeId": "120214682926100250",
"adCreativeName": "Static_2"
},
"gaid": "38400000-8cf0-11bd-b23e-10b96e40000d",
"idfa": null
}Setting User Data
Call setUserData to send user details and the IDs your product analytics tools use for this user. You can call it right after init, before the user logs in: id is optional for setUserData. Pass id once the user is logged in.
When you pass a tool's ID and that integration is configured in Linkrunner, Linkrunner sends this install's attribution to that tool for this user, the same attribution it sends after signup (for example, lr_campaign and lr_ad_network on the Mixpanel profile). This applies to installs attributed to a campaign. If the install is not attributed yet, Linkrunner sends the properties once attribution completes. Supported IDs:
| Tool | Field |
|---|---|
| Mixpanel | mixpanel_distinct_id |
| Amplitude | amplitude_device_id |
| PostHog | posthog_distinct_id |
| MoEngage | moengage_user_id |
| Braze | braze_device_id |
| Google Analytics 4 | ga_app_instance_id and ga_session_id |
| Netcore | netcore_device_guid |
setUserData is not a replacement for signup. Call signup as soon as the user is identified (signup or login). signup still requires id.
Calling setUserData without id requires Capacitor SDK 2.3.0 or later. On earlier versions id is required.
Right after init, before the user logs in:
typescript
import linkrunner from "capacitor-linkrunner";
const setAnalyticsIds = async (mixpanelDistinctId: string) => {
await linkrunner.setUserData({
mixpanel_distinct_id: mixpanelDistinctId,
});
};After the user logs in:
typescript
import linkrunner from "capacitor-linkrunner";
const setUserData = async () => {
await linkrunner.setUserData({
id: "123", // Your customer user ID
name: "John Doe", // Optional
phone: "9876543210", // Optional
email: "user@example.com", // Optional
mixpanel_distinct_id: "mixpanel_distinct_id", // Optional
});
};Setting CleverTap ID
Use the setAdditionalData method to set CleverTap ID:
typescript
import linkrunner from "capacitor-linkrunner";
const setIntegrationData = async () => {
await linkrunner.setAdditionalData({
clevertapId: "YOUR_CLEVERTAP_USER_ID", // CleverTap user identifier
});
};Parameters for linkrunner.setAdditionalData
clevertapId: string (optional) - CleverTap user identifier
This method allows you to connect user identities across different analytics and marketing platforms.
Meta Anonymous ID
If your app also has the Meta (Facebook) SDK, update to capacitor-linkrunner 3.2.0. Linkrunner reads the Meta SDK's anonymous ID automatically and sends it with your events, and the Linkrunner backend passes it to Meta as anon_id. Meta then matches those events to the same device it already knows from its own SDK. There is no code for you to write.
No set-up order is required. Linkrunner and the Meta SDK can start in either order, and if the Meta SDK only starts later, for example after a consent prompt, the ID is picked up on the next event. In apps without the Meta SDK nothing is read and nothing extra is sent.
Finish the setup by removing your own Meta logEvent calls for the events you already send through Linkrunner, so each event reaches Meta from one source instead of two.
For a privacy review: Linkrunner reads a single value, the Meta SDK's anonymous app ID. The Meta SDK creates it on the device, it is scoped to your app, and Linkrunner sends it only to Meta. Linkrunner creates no ID of its own and never writes to the Meta SDK's storage. Supported on Android and iOS.
Turning it off
Add the opt-out flag to each native project:
xml
<!-- android/app/src/main/AndroidManifest.xml, inside <application> -->
<meta-data
android:name="io.linkrunner.sdk.MetaAnonymousIdCollectionEnabled"
android:value="false" />xml
<!-- ios/<YourApp>/Info.plist -->
<key>LinkrunnerMetaAnonymousIdCollectionEnabled</key>
<false/>With the flag set, the SDK makes no lookup and sends no meta_anonymous_id.
Revenue Tracking
Revenue is stored for all users, including organic ones. Payments from users with no matching click are stored without campaign attribution. Pass your user ID as userId so each payment is linked to the user who paid. You can verify your events are being captured on the Events page.
Tracking Payments
A payment is an in-app event with revenue. Send it with trackEvent, and put amount, paymentId, and currency in eventData. The event name becomes the payment type in reports and mappings, so you can use any name, such as purchase or SUBSCRIPTION_RENEWED. Requires capacitor-linkrunner 3.0.0 or later. For examples for every case and how payments reach ad networks, see the full Track payments guide.
This example sends every payment key. amount, paymentId, currency, and userId are required for a payment.
javascript
import linkrunner, { PaymentStatus } from "capacitor-linkrunner";
const trackPurchase = async () => {
try {
await linkrunner.trackEvent(
"purchase", // Payment name, stored as the payment type in reports and mappings
{
amount: 1499, // Required for a payment: total the user paid, a finite number >= 0
paymentId: "order_123", // Required for a payment: your order or transaction ID, used to deduplicate
currency: "INR", // Required for a payment: 3-letter ISO 4217 code
userId: "user_123", // Required for a payment: your user ID. "" uses the user saved by signup or setUserData
status: PaymentStatus.PAYMENT_COMPLETED, // Optional: defaults to PAYMENT_COMPLETED (see statuses below)
// Optional: any other keys stay as event data. Meta and Google read these product fields
content_ids: ["sku_1", "sku_2"],
contents: [
{ id: "sku_1", quantity: 1, item_price: 999 },
{ id: "sku_2", quantity: 1, item_price: 500 },
],
content_type: "product",
num_items: 2,
order_id: "order_123",
},
"evt_order_123" // Optional: your own ID for this event
);
} catch (error) {
// On Android an invalid payment rejects here, and nothing is sent
console.error("Error tracking payment:", error);
}
};Payment keys in eventData
| Key | Type | Required | Description |
|---|---|---|---|
amount | number | Yes | Total the user paid. Must be a finite number, 0 or greater. This is the revenue value. |
paymentId | string | Yes | Your order or transaction ID. Must not be blank. Used to recognize the same payment when it arrives again. |
currency | string | Yes | 3-letter ISO 4217 currency code, such as INR or USD. Case-insensitive, sent in uppercase. |
userId | string | Yes | Your ID for the user who paid. If you pass an empty string, the SDK uses the user saved by signup or setUserData. |
status | string | No | PAYMENT_INITIATED, PAYMENT_COMPLETED (default), PAYMENT_FAILED, or PAYMENT_CANCELLED. |
| Any other key | Any | No | Stays in the event data, such as product details for Meta Commerce Manager. |
How trackEvent decides:
amount,paymentId, andcurrencyare all ineventData: the event is a payment. The SDK checks the payment keys and sends them as payment fields.- None of them, or
amountorcurrencywithoutpaymentId: the event is a normal custom event, exactly as before. Anamountorcurrencykey on its own is ordinary event data. paymentIdwithamountorcurrencymissing: The promise returned bytrackEventrejects withamount, paymentId and currency must be sent together, and nothing is sent. On iOS the payment is dropped instead and debug builds log the reason.- A negative or non-numeric
amount, a blankpaymentId, a currency that is not 3 letters, or an unknownstatus: The promise returned bytrackEventrejects, and nothing is sent. On iOS the payment is dropped instead and debug builds log the reason.
Payment status
capacitor-linkrunner exports PaymentStatus as an object of string values. Plain strings such as "PAYMENT_COMPLETED" also work.
| Status | Use it when | Effect |
|---|---|---|
PAYMENT_INITIATED | The user started paying, such as opening the checkout or payment sheet. | Stored for reports and analytics. Not added to revenue and not sent to ad networks. |
PAYMENT_COMPLETED (default) | The charge succeeded. | Added to revenue and paying users. Sent to ad networks when the event name is mapped. |
PAYMENT_FAILED | The charge was declined or errored. | Stored for reports and analytics. Not added to revenue and not sent to ad networks. |
PAYMENT_CANCELLED | The user backed out before paying, or you refunded it. Send it with the same event name, paymentId, amount, and currency as the completed payment. | Stored for reports and analytics. The payment no longer counts as revenue and nothing is sent to ad networks. |
Linkrunner keeps one payment per paymentId, event name, and status, so a retry with the same values is recorded once. See Payment status for a full lifecycle example.
The event name is stored exactly as you send it. If you used one of the old payment types, pass it in uppercase exactly as before, such as FIRST_PAYMENT or DEFAULT, so your existing mappings and reports keep working. A different spelling such as first_payment is a new payment type. Any other name, such as purchase, is also stored as sent, and you need to add a mapping for it in the dashboard before it reaches ad networks.
capturePayment and removePayment are deprecated. They still work in 3.0.0 and show a deprecation warning, and they will be removed in a future major version. Use trackEvent with the payment keys instead. Apps on capacitor-linkrunner 2.x keep working unchanged. To move, see Migrate payments to in-app events.
Tracking Custom Events
From Capacitor SDK v1.3.0, custom events automatically include the user_id you set during signup() / setUserData(). The SDK stores this identifier securely on-device and attaches it to every trackEvent call, so you no longer need to pass it manually. Events tracked before signup are sent without a user_id.
Events are stored for all users, including organic ones. Events from users with no matching click are stored without campaign attribution. Call .signup so events are linked to a user. You can verify your events are being captured on the Events page. To record revenue, add the payment keys to eventData.
Track custom events in your app:
typescript
import linkrunner from "capacitor-linkrunner";
const trackEvent = async () => {
await linkrunner.trackEvent(
"purchase_initiated", // Event name
{ product_id: "12345", category: "electronics" }, // Optional: Event data
"order_12345" // Optional: Your own unique event identifier (string or number)
);
};Parameters for linkrunner.trackEvent
eventName: string (required) - Name of the event to trackeventData: object (optional) - Key-value pairs for additional event data, including Meta ecommerce properties. Addamount,paymentId,currency, anduserIdto make it a payment. See Tracking Payments.eventId: string | number (optional) - Your own unique identifier for the event, useful for deduplication and correlating with your backend
Revenue Sharing with Ad Networks
Send revenue to ad networks such as Google Ads and Meta as a payment. Meta and Google receive the value and currency from the payment amount and currency, so send the order total as amount. Linkrunner does not add up item prices.
Put the payment keys and the product details in eventData. Meta receives content_ids, contents, content_type, num_items, and order_id. Google receives content_ids as item IDs.
typescript
const trackPurchase = async () => {
try {
await linkrunner.trackEvent("purchase", {
amount: 149.99, // Order total, sent to ad networks as the value
paymentId: "order_12345",
currency: "USD",
userId: "user_123",
content_ids: ["product_123"],
num_items: 1,
order_id: "order_12345",
});
} catch (error) {
console.error("Error tracking payment:", error);
}
};An amount in eventData is revenue only when paymentId and currency are there too. On its own it is ordinary event data. Revenue is shared only when Send Revenue is turned on for the event's mapping in the dashboard. See Meta Ads and Google Ads.
Enhanced Privacy Controls
The SDK offers options to enhance user privacy:
typescript
import linkrunner from "capacitor-linkrunner";
// Enable PII (Personally Identifiable Information) hashing
linkrunner.enablePIIHashing(true);When PII hashing is enabled, sensitive user data like name, email, and phone number are hashed using SHA-256 before being sent to Linkrunner servers.
Privacy mode
Use privacy mode for apps directed at children. It stops the native SDKs from collecting any device-level identifier. On Android: no Google Advertising ID, App Set ID or Android ID, no local IP address, no carrier name and no Meta install referrer. On iOS: no IDFA, no ATT prompt, no IDFV, no Google on-device conversion value, no user-assigned device name and no SKAdNetwork conversion values. Only the SDK's install instance ID identifies the install.
It needs native Android SDK 5.1.0 and iOS SDK 5.1.0. Use capacitor-linkrunner 3.1.0 or later.
Pass true as the sixth argument of init, after debug:
typescript
import linkrunner from "capacitor-linkrunner";
await linkrunner.init(
"YOUR_PROJECT_TOKEN",
undefined, // secretKey
undefined, // keyId
false, // disableIdfa
false, // debug
true // privacyMode
);The SDK saves the setting. true stays on across launches until you call init with privacyMode set to false. If you leave the argument out, the SDK keeps the saved value.
When privacy mode is on:
- On iOS, skip the
NSUserTrackingUsageDescriptionkey in Step 3 and the SKAdNetwork keys in Step 4. - On Android, remove the
AD_IDpermission from your manifest, because the SDK still declares it.
For everything privacy mode removes, what is still sent, and how it changes your store privacy answers, see Privacy mode.
Uninstall Tracking
Before you begin
Here's what you need to know before getting started:
Requirements:
- Capacitor SDK 1.0.1 and later
- Firebase in your Capacitor project (Android)
- Registering your app with APNs (iOS)
Android
Connect Firebase Cloud Messaging (FCM) with Linkrunner
FCM HTTP v1 API
To configure FCM HTTP V1 for uninstalls:
Enable the FCM API:
- Go to the FCM console.
- Select a project.
- Go to Project Overview > Project settings.
- Copy the Project ID. This will be required in a later step.

- Go to the Cloud Messaging tab.
- Make sure that Firebase Cloud Messaging API (V1) is set to Enabled.
Create a custom role for Linkrunner Uninstall:
- Go to the Service accounts tab.
- Click Manage service account permissions.
- A new browser tab opens in Google Cloud Platform.
- In the side menu, select Roles.
- Click + Create role.
- Enter the following details:
- Title: Linkrunner Uninstalls
- ID: lr_uninstalls
- Role launch stage: General availability
- Click + Add permissions.
- In Enter property name or value field, enter
cloudmessaging.messages.createand select it from the search results.
- Check the cloudmessaging.messages.create option and click Add.
- Click Create.
Assign Linkrunner the FCM uninstall role:
- In the side menu, select IAM.
- Open the View by Principals tab.
- Click Grant Access.
- In Add Principals -> New principals field, enter
lr-uninstalls-tracking@lr-uninstalls-tracking.iam.gserviceaccount.com - In Assign Roles -> Select a role field, enter
Linkrunner Uninstallsand select it from the search results. - Click Save.
The Linkrunner service account has been assigned the role of Linkrunner Uninstalls.
Linkrunner Dashboard
- In Linkrunner, go to Settings > Uninstall Tracking.
- Under the Android tab, enter the Firebase Project ID that you copied initially and click Save.
![]()
Integrate with Linkrunner SDK
Follow these instructions to integrate FCM with the Linkrunner SDK:
- Set up Push Notifications:
Set up push notifications in your Capacitor app. See the Capacitor Push Notifications documentation for detailed instructions.
- Configure your app to provide the device's push token to the Linkrunner SDK.
typescript
import { PushNotifications } from '@capacitor/push-notifications';
import linkrunner from 'capacitor-linkrunner';
// Request permission and get token
const initializePushNotifications = async () => {
const permStatus = await PushNotifications.requestPermissions();
if (permStatus.receive === 'granted') {
await PushNotifications.register();
}
};
// Listen for registration
PushNotifications.addListener('registration', async (token) => {
await linkrunner.setPushToken(token.value);
});
// Handle incoming push notifications
PushNotifications.addListener('pushNotificationReceived', (notification) => {
if (notification.data && notification.data['lr-uninstall-tracking']) {
// Silent notification for uninstall tracking, ignore
return;
}
// Handle other notifications here
});Custom implementations of push notification handlers can unintentionally make uninstall push notifications visible to users, disrupting the intended silent experience. To avoid this, ensure your logic checks if the notification contains lr-uninstall-tracking and handles it accordingly, as shown in the code example above.
iOS
Connect APNs with Linkrunner
Apple Developer Portal
Get the required credentials from the Apple Developer Portal:
APNs Authentication Key (p8) and Key ID:
- Go to the Apple Developer Portal.
- Select Identifiers under Certificates, IDs & Profiles.
- Click on the app you want to track uninstalls for. Then, under Capabilities, search for Push Notifications and enable it.
- Under Certificates, IDs & Profiles, select Keys and click on plus (+) icon to create a key. Enable APNs when creating the key and download the key file (p8).
- The Key ID can be found in the Keys tab.
Bundle ID and Team ID:
- Under Identifiers, click on your app and you will see the Bundle ID and Team ID (App ID Prefix).
Linkrunner Dashboard
- In Linkrunner, go to Settings > Uninstall Tracking.
- Under the iOS tab, upload the APNs Authentication Key (p8) file and enter the Key ID, Bundle ID and Team ID (App ID Prefix) that you copied from the Apple Developer Portal.
![]()
Integrate with Linkrunner SDK
Follow these instructions to integrate APNs with the Linkrunner SDK:
- Set up Push Notifications:
Set up push notifications in your Capacitor app if you haven't already. See the Capacitor Push Notifications documentation for detailed instructions.
- Configure your app to provide the device's APNs token to the Linkrunner SDK.
For iOS, the token received from the registration event is the APNs token when running on iOS devices:
typescript
import { PushNotifications } from '@capacitor/push-notifications';
import { Capacitor } from '@capacitor/core';
import linkrunner from 'capacitor-linkrunner';
// Listen for registration - on iOS this provides the APNs token
PushNotifications.addListener('registration', async (token) => {
if (Capacitor.getPlatform() === 'ios') {
await linkrunner.setPushToken(token.value);
}
});Function Placement Guide
| Function | Requirement | Where to Place | When to Call |
|---|---|---|---|
linkrunner.init | Required | App initialization | Once when app starts |
linkrunner.signup | Required | Identification flow (signup or login) | Once when the user is identified |
linkrunner.setCustomerUserId | Required | After init, when your user ID is available | As early as the user's ID is available |
linkrunner.handleDeeplink | Required | Deep link entry points | When app is opened via a deep link |
linkrunner.getAttributionData | Optional | Attribution data handling flow | Whenever the attribution data is needed |
linkrunner.setAdditionalData | Optional | Integration code | When third-party integration IDs are available |
linkrunner.setUserData | Optional | App start, authentication or profile update logic | Right after init with your analytics IDs, and when user details become available |
linkrunner.trackEvent | Optional | Throughout app | When specific user actions occur |
linkrunner.trackEvent with payment keys | Optional | Payment processing | When user makes a payment |
linkrunner.setPushToken | Optional | Push notification setup | When push token is available |
linkrunner.enablePIIHashing | Optional | Privacy configuration | When enabling PII hashing |
Publishing to Google Play or the App Store? See Data the SDK collects for what the SDK sends and the answers for the Play Data safety form and Apple's App Privacy questions.
Next Steps
Test Your Integration
Validate your setup end-to-end
Set Up Deep Linking
Configure deep links for your app
Support
If you encounter issues during integration, contact us at support@linkrunner.io.