Linkrunner

https://docs.linkrunner.io/
Admin
Linkrunner is a Mobile Measurement Partner (MMP) that tracks every user journey from first click to...
Tokens:178,224
Snippets:1,686
Trust Score:6.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Event Payload Example

Source: https://docs.linkrunner.io/features/webhooks

This JSON payload represents an install event, including campaign details, attribution timestamps, and user/device identifiers.

```json
{
  "event_type": "install",
  "user_id": null,
  "campaign_id": "camp_XYZ123",
  "ad_channel": "META",
  "network_name": "META",
  "app_version": "2.4.1",
  "campaign_name": "Summer Promotion 2023",
  "attributed_on": "2026-03-24T08:11:00.464Z",
  "installed_at": "2026-03-24T08:11:00.464Z",
  "store_click_at": "2026-03-24T08:11:00.464Z",
  "link": "https://dl.linkrunner.io/?c=camp_XYZ123",
  "meta_campaign_details": { ... },
  "google_campaign_details": null,
  "gaid": "bk9384xs-p449-96ds-r132",
  "idfa": null,
  "name": null,
  "phone": null,
  "email": null,
  "additional_data": null
}
```

--------------------------------

### Campaign Attribution Example

Source: https://docs.linkrunner.io/features/referral-codes

Example of query parameters used for attributing app installs to specific marketing campaigns and their sources.

```url
?campaign=summer_sale&source=instagram
```

--------------------------------

### Install Capacitor SDK

Source: https://docs.linkrunner.io/quickstart

Install the Capacitor Linkrunner plugin and sync your project.

```bash
npm install capacitor-linkrunner
npx cap sync
```

--------------------------------

### User Signup and Identification with Linkrunner

Source: https://docs.linkrunner.io/sdk/react-native/installation

Call the `signup` method as soon as the user is identified to tie installs and future events to a user identifier. This example includes optional user data fields for tracking reinstalls and integrating with analytics platforms like Mixpanel, Amplitude, and PostHog.

```javascript
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);
    }
};

```

--------------------------------

### Complete Flutter Integration Example

Source: https://docs.linkrunner.io/sdk/flutter/installation

A simplified example demonstrating Linkrunner initialization with a project token, and tracking a custom event. Ensure you replace 'YOUR_PROJECT_TOKEN' with your actual token.

```dart
import 'package:flutter/material.dart';
import 'package:linkrunner/linkrunner.dart';

final linkrunner = LinkRunner();

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Linkrunner Demo',
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  bool _initialized = false;

  @override
  void initState() {
    super.initState();
    _initializeLinkrunner();
  }

  Future<void> _initializeLinkrunner() async {
    try {
      await LinkRunner().init('YOUR_PROJECT_TOKEN');
      setState(() {
        _initialized = true;
      });
    } catch (e) {
      print('Error initializing LinkRunner: $e');
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Linkrunner Demo')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('LinkRunner ${_initialized ? 'Initialized' : 'Initializing...'}'),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: () async {
                await LinkRunner().trackEvent(eventName: 'button_clicked');
              },
              child: Text('Track Custom Event'),
            ),
          ],
        ),
      ),
    );
  }
}

```

--------------------------------

### Install Webhook

Source: https://docs.linkrunner.io/features/webhooks

The `install` webhook is triggered when Linkrunner attributes an app installation. It includes device identifiers but the `user_id` will be null.

```APIDOC
## Install Webhook

### Description
Triggered immediately when Linkrunner attributes an app installation. The `user_id` field will be `null`, but device identifiers (`gaid`, `idfa`) are included.

### Event
`install`

### Payload Structure
POST request with a JSON body containing attribution data.

### Headers
- `Content-Type`: `application/json`
- `linkrunner-key`: Your project's private key for authentication
```

--------------------------------

### iOS Pod Installation

Source: https://docs.linkrunner.io/sdk/react-native/installation

After installing the package, navigate to the ios directory and install the necessary pods.

```bash
cd ios && pod install
```

--------------------------------

### User Identification (Signup)

Source: https://docs.linkrunner.io/sdk/capacitor

Call the `signup` method to tie installs and events to a user identifier. This is crucial for tracking user activity and attributing installs correctly.

```APIDOC
## signup

### Description

Initiates the user signup process, associating the current installation and future events with a unique user identifier. It's recommended to call this as soon as a user is identified (signup or login).

### Method

```typescript
linkrunner.signup(options: {
    user_data: {
        id: string; // Required: User ID
        name?: string; // Optional
        phone?: string; // Optional
        email?: string; // Optional
        user_created_at?: string; // Optional: For tracking reinstalls
        is_first_time_user?: boolean; // Optional: For tracking reinstalls
        mixpanel_distinct_id?: string; // Optional: Mixpanel Distinct ID
        amplitude_device_id?: string; // Optional: Amplitude User ID
        posthog_distinct_id?: string; // Optional: PostHog Distinct ID
    };
    data?: Record<string, any>; // Optional: Any additional data
}): Promise<void>;
```

### Parameters

#### `user_data` (Object) - Required

An object containing user identification and optional tracking properties.

- **`id`** (string) - Required - The unique identifier for the user.
- **`name`** (string) - Optional - The user's full name.
- **`phone`** (string) - Optional - The user's phone number.
- **`email`** (string) - Optional - The user's email address.
- **`user_created_at`** (string) - Optional - Timestamp indicating when the user was created, used for tracking reinstalls.
- **`is_first_time_user`** (boolean) - Optional - Flag to indicate if this is the user's first time using the app, used for tracking reinstalls.
- **`mixpanel_distinct_id`** (string) - Optional - The distinct ID for Mixpanel integration.
- **`amplitude_device_id`** (string) - Optional - The device ID for Amplitude integration.
- **`posthog_distinct_id`** (string) - Optional - The distinct ID for PostHog integration.

#### `data` (Object) - Optional

An object for any additional custom data to be sent with the signup event.

### Request Example

```typescript
await linkrunner.signup({
    user_data: {
        id: "123",
        name: "John Doe",
        phone: "9876543210",
        email: "user@example.com",
        user_created_at: "2024-01-01T00:00:00Z",
        is_first_time_user: true,
        mixpanel_distinct_id: "mixpanel_distinct_id",
        amplitude_device_id: "amplitude_device_id",
        posthog_distinct_id: "posthog_distinct_id",
    },
    data: {},
});
```
```

--------------------------------

### Referral Program Example

Source: https://docs.linkrunner.io/features/referral-codes

Example of a query parameter format for tracking users in a referral program.

```url
?referrer=user_12345
```

--------------------------------

### Install React Native SDK

Source: https://docs.linkrunner.io/sdk/react-native/usage

Install the Linkrunner SDK using npm or yarn.

```bash
# Using npm
npm install rn-linkrunner

# Using yarn
yarn add rn-linkrunner

```

--------------------------------

### Promo Code Example

Source: https://docs.linkrunner.io/features/referral-codes

Example of query parameters for tracking the usage of promotional codes, often combined with referrer information.

```url
?promo=SAVE20&referrer=email_campaign
```

--------------------------------

### Install Linkrunner SDK via NPM or Yarn

Source: https://docs.linkrunner.io/sdk/web

Install the SDK package using your preferred package manager.

```bash
# Using npm
npm install @linkrunner/web-sdk

# Using yarn
yarn add @linkrunner/web-sdk
```

--------------------------------

### Install Expo SDK

Source: https://docs.linkrunner.io/quickstart

Install the Expo Linkrunner and React Native SDK using npx expo install.

```bash
npx expo install expo-linkrunner rn-linkrunner
```

--------------------------------

### Install Cordova SDK

Source: https://docs.linkrunner.io/quickstart

Add the Linkrunner Cordova plugin to your project.

```bash
cordova plugin add cordova-plugin-linkrunner
```

--------------------------------

### Initialize Linkrunner SDK and Handle Warm Start Deeplinks

Source: https://docs.linkrunner.io/sdk/cordova

Initialize the Linkrunner SDK within the Cordova `deviceready` event and set up the `handleOpenURL` function to capture and process warm start deeplinks for remarketing purposes.

```javascript
// Initialize SDK first
document.addEventListener('deviceready', function () {
    linkrunner.init({ token: "YOUR_PROJECT_TOKEN" });
}, false);

// Handle warm start deeplinks
window.handleOpenURL = function (url) {
    linkrunner.handleDeeplink(url).then(function (data) {
        console.log("Deeplink data:", JSON.stringify(data));

        if (data.data && data.data.is_linkrunner) {
            // This is a Linkrunner deeplink - navigate accordingly
            var deeplink = data.data.deeplink;
            console.log("Navigate to:", deeplink);
        }
    }).catch(function (error) {
        console.error("Deeplink handling failed:", error);
    });
};
```

--------------------------------

### LinkrunnerSDK Initialization

Source: https://docs.linkrunner.io/sdk/ios/installation

Initialize the Linkrunner SDK with your project token. This should be done once when your app starts.

```APIDOC
## LinkrunnerSDK.shared.initialize

### Description
Initializes the Linkrunner SDK with a provided project token.

### Method Signature
`LinkrunnerSDK.shared.initialize(token: String) async throws`

### Parameters
- **token** (String) - Required - Your unique project token.

### When to Call
Once when the app starts during app initialization.
```

--------------------------------

### Install iOS SDK

Source: https://docs.linkrunner.io/quickstart

Add the Linkrunner SDK to your iOS project's Podfile.

```ruby
# Podfile
pod 'Linkrunner'
```

--------------------------------

### Install Linkrunner SDK via CDN

Source: https://docs.linkrunner.io/sdk/web

Include this script tag in your HTML to automatically initialize the SDK. Replace YOUR_PROJECT_TOKEN with your actual token. Debug mode is enabled by default.

```html
<script src="https://sdk.linkrunner.io/latest/linkrunner-sdk.min.js" token="YOUR_PROJECT_TOKEN" debug="true"></script>
```

--------------------------------

### User Identification (Signup/Login)

Source: https://docs.linkrunner.io/sdk/android/installation

Call the `signup` method to associate installs and events with a user identifier. This should be called as soon as a user is identified, typically after signup or login. You can optionally pass user details and integration-specific IDs for services like Mixpanel, PostHog, and Amplitude.

```APIDOC
## 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.
* mixpanelDistinctId for Mixpanel
* posthogDistinctId for PostHog
* amplitudeDeviceId for Amplitude

```kotlin
private fun onSignup() {
    CoroutineScope(Dispatchers.IO).launch {
        try {
            val userData = UserDataRequest(
                id = "123", // Required: User ID
                name = "John Doe", // Optional
                phone = "9876543210", // Optional
                email = "user@example.com", // Optional
                mixpanelDistinctId = "mixpanel_distinct_id", // Optional - Mixpanel Distinct ID
                amplitudeDeviceId = "amplitude_device_id", // Optional - Amplitude User ID
                posthogDistinctId = "posthog_distinct_id" // Optional - PostHog Distinct ID
                userCreatedAt = "2024-01-01T00:00:00Z", // Optional
                isFirstTimeUser = true, // Optional
            )

            LinkRunner.getInstance().signup(
                userData = userData,
                additionalData = mapOf("custom_field" to "custom_value") // Optional: Any additional data
            )
            println("Signup successful")
        } catch (e: Exception) {
            println("Exception during signup: ${e.message}")
        }
    }
}
```
```

--------------------------------

### Get Attribution Data

Source: https://docs.linkrunner.io/sdk/capacitor

Retrieves attribution data and deeplink information for the current app installation.

```APIDOC
## getAttributionData

### Description

Fetches attribution data and deeplink information associated with the current app installation. This data can be used to understand the source of the installation and user acquisition campaigns.

### Method

```typescript
linkrunner.getAttributionData(): Promise<{
    deeplink: string | null;
    campaignData: {
        id: string;
        name: string;
        type: "ORGANIC" | "INORGANIC";
        adNetwork: "META" | "GOOGLE" | null;
        installedAt: string;
        storeClickAt: string | null;
        groupName: string;
        assetName: string;
        assetGroupName: string;
    } | null;
}>;
```

### Response

#### Success Response

Returns an object containing `deeplink` information and `campaignData`.

- **`deeplink`** (string | null) - The deeplink associated with the installation, or null if none.
- **`campaignData`** (Object | null) - An object containing details about the attribution campaign, or null if no campaign data is available.
    - **`id`** (string) - The unique identifier for the campaign.
    - **`name`** (string) - The name of the campaign.
    - **`type`** (string) - The type of campaign, either "ORGANIC" or "INORGANIC".
    - **`adNetwork`** (string | null) - The ad network used, such as "META" or "GOOGLE", or null if not applicable.
    - **`installedAt`** (string) - The timestamp when the app was installed.
    - **`storeClickAt`** (string | null) - The timestamp when the user clicked the store link, or null if not available.
    - **`groupName`** (string) - The name of the ad group.
    - **`assetName`** (string) - The name of the ad asset.
    - **`assetGroupName`** (string) - The name of the ad asset group.

### Response Example

```json
{
    "deeplink": "myapp://open?campaign=summer_sale",
    "campaignData": {
        "id": "campaign_123",
        "name": "Summer Sale 2024",
        "type": "INORGANIC",
        "adNetwork": "GOOGLE",
        "installedAt": "2024-07-26T10:00:00Z",
        "storeClickAt": "2024-07-25T15:30:00Z",
        "groupName": "Mobile Ads",
        "assetName": "Banner Ad 1",
        "assetGroupName": "Summer Campaign Assets"
    }
}
```
```

--------------------------------

### Get Attribution Data

Source: https://docs.linkrunner.io/sdk/ios/usage

Retrieve attribution data and deeplink information for the current installation using the `getAttributionData` function. This data includes the deeplink URL that led to the app installation and campaign details.

```swift
func getAttributionInfo() async {
    do {
        let attributionData = try await LinkrunnerSDK.shared.getAttributionData()
        print("Attribution data:", attributionData)

        // Attribution data includes:
        // - deeplink: The deep link URL that led to app installation
        // - campaignData: Campaign information
        if let deeplink = attributionData.deeplink {
            print("Deeplink:", deeplink)
            // Handle the deeplink in your app
        }
    } catch {
        print("Error getting attribution data:", error)
    }
}
```

```swift
struct AttributionData: Codable, Sendable {
    let deeplink: String?
    let campaignData: CampaignData
    let attributionSource: String
}

struct CampaignData: Codable, Sendable {
    let id: String
    let name: String
    let adNetwork: String?
    let type: String
    let installedAt: String
    let storeClickAt: String?
    let groupName: String
    let assetName: String
    let assetGroupName: String
}
```

--------------------------------

### Get Attribution Data from Linkrunner SDK

Source: https://docs.linkrunner.io/sdk/capacitor

Retrieve attribution data and deeplink information for the current installation using the `getAttributionData` function. This function returns details about the deeplink and campaign data associated with the installation.

```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);
    }
};
```

--------------------------------

### Getting Attribution Data

Source: https://docs.linkrunner.io/sdk/cordova

Retrieve attribution data and deeplink information for the current installation using the `getAttributionData` function.

```APIDOC
## getAttributionData

### Description
Fetches attribution data and deeplink information associated with the current app installation.

### Method
`linkrunner.getAttributionData()`

### Response
#### Success Response
Returns an object containing attribution and deeplink information.

- **deeplink** (string | null) - The deep link URL, if available.
- **campaignData** (object | null) - An object containing campaign details:
  - **id** (string) - The campaign ID.
  - **name** (string) - The campaign name.
  - **type** (string) - The campaign type (`ORGANIC` or `INORGANIC`).
  - **adNetwork** (string | null) - The ad network (`META`, `GOOGLE`, or null).
  - **installedAt** (string) - The installation timestamp.
  - **storeClickAt** (string | null) - The timestamp of the store click, if available.
  - **groupName** (string) - The name of the ad group.
  - **assetName** (string) - The name of the ad asset.
  - **assetGroupName** (string) - The name of the ad asset group.

### Request Example
```javascript
linkrunner.getAttributionData().then(function (attributionData) {
    console.log("Attribution data:", JSON.stringify(attributionData));
}).catch(function (error) {
    console.error("Error getting attribution data:", error);
});
```

### Response Example
```json
{
    "deeplink": "https://...",
    "campaignData": {
        "id": "string",
        "name": "string",
        "type": "ORGANIC" | "INORGANIC",
        "adNetwork": "META" | "GOOGLE" | null,
        "installedAt": "string",
        "storeClickAt": "string" | null,
        "groupName": "string",
        "assetName": "string",
        "assetGroupName": "string"
    }
}
```
```

--------------------------------

### Initialize Linkrunner SDK

Source: https://docs.linkrunner.io/sdk/unity

Call this as early as possible in your startup scene. Ensure you replace 'YOUR_PROJECT_TOKEN' with your actual project token. Set 'debug' to false for production builds.

```csharp
void Start()
{
    LinkrunnerSDK.OnInitialized += (success, message) =>
    {
        Debug.Log($"Linkrunner initialized: {success}");
    };

    LinkrunnerSDK.Initialize(
        token: "YOUR_PROJECT_TOKEN",
        debug: true  // set false in production
    );
}
```

--------------------------------

### Get Attribution Result

Source: https://docs.linkrunner.io/api-reference/data-apis

Retrieve attribution data for a specific user or device. This endpoint returns campaign and ad network information for attributed installs.

```APIDOC
## GET /get-attribution-result

### Description
Retrieve attribution data for a specific user or device. This endpoint returns campaign and ad network information for attributed installs.

### Method
GET

### Endpoint
/get-attribution-result

### Parameters
#### Query Parameters
- **device_identifier** (string) - Conditional - The unique device ID to look up. For Android, this is the GAID (Google Advertising ID). For iOS, this is the IDFA (Identifier for Advertisers). Required if `user_id` is not provided.
- **user_id** (string) - Conditional - The user ID to look up. Required if `device_identifier` is not provided.

**Note**: At least one of `device_identifier` or `user_id` must be provided. If both are provided and they match different installs, the `user_id` based result will be returned as it's more reliable.

### Request Example
1. **Get Attribution by Device Identifier**:
```
GET /get-attribution-result?device_identifier=550e8400-e29b-41d4-a716-446655440000
```
2. **Get Attribution by User ID**:
```
GET /get-attribution-result?user_id=user123456
```
3. **Get Attribution with Both Identifiers**:
```
GET /get-attribution-result?device_identifier=550e8400-e29b-41d4-a716-446655440000&user_id=user123456
```

### Response
#### Success Response (200)
- **msg** (string) - Attribution result retrieved successfully.
- **status** (integer) - HTTP status code, expected to be 200.
- **data** (object) - Contains the attribution details.
  - **campaign_name** (string) - The name of the campaign.
  - **display_id** (string) - The display ID of the campaign.
  - **deeplink** (string) - The deep link URL for the campaign.
  - **domain_name** (string) - The domain name used for the campaign links.
  - **ad_set_id** (string) - The ID of the ad set.
  - **ad_set_name** (string) - The name of the ad set.
  - **ad_creative_id** (string) - The ID of the ad creative.
  - **ad_creative_name** (string) - The name of the ad creative.
  - **keyword_id** (string) - The ID of the keyword (if applicable).
  - **keyword_name** (string) - The name of the keyword (if applicable).
  - **ad_network** (string) - The ad network used.
  - **attribution_type** (string) - The type of attribution (e.g., INORGANIC).

#### Response Example (200)
```json
{
    "msg": "Attribution result retrieved successfully.",
    "status": 200,
    "data": {
        "campaign_name": "Summer Sale 2024",
        "display_id": "XYZ123",
        "deeplink": "https://app.domain.com/promo/summer",
        "domain_name": "app.domain.com",
        "ad_set_id": "138726384957162840",
        "ad_set_name": "Engagement Campaign",
        "ad_creative_id": "138726495084763210",
        "ad_creative_name": "Creative Variation 1",
        "keyword_id": "",
        "keyword_name": "",
        "ad_network": "META",
        "attribution_type": "INORGANIC"
    }
}
```

#### No Attribution Data (204)
If no attribution data is found for the provided identifier, the API returns a `204 No Content` status with an empty response body.
```

--------------------------------

### Signup User with Linkrunner

Source: https://docs.linkrunner.io/sdk/unity

Call `Signup` as soon as the user is identified (signup or login) to tie installs and events to a user identifier. Provide user details like ID, name, and email.

```csharp
var userData = new LinkrunnerUserData
{
    id = "user_123",
    name = "Jane Doe",
    email = "jane@example.com",
    isFirstTimeUser = true
};

LinkrunnerSDK.Signup(userData);
```

--------------------------------

### Get Attribution Result with Both Identifiers

Source: https://docs.linkrunner.io/api-reference/data-apis

Retrieve attribution data using both device identifier and user ID. If they match different installs, the user_id result is returned.

```http
GET /get-attribution-result?device_identifier=550e8400-e29b-41d4-a716-446655440000&user_id=user123456
```

--------------------------------

### User Identification and Signup

Source: https://docs.linkrunner.io/sdk/ios/usage

Call the `signup` method as soon as the user is identified to tie installs and events to a user identifier. It's recommended to use the platform's identify function or provide specific identifiers if not available.

```APIDOC
## 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.
  * mixpanelDistinctId for Mixpanel
  * amplitudeDeviceId for Amplitude
  * posthogDistinctId for PostHog

```swift
func onSignup() async {
    do {
        let userData = UserData(
            id: "123", // Required: User ID
            name: "John Doe", // Optional
            phone: "9876543210", // Optional
            email: "user@example.com", // Optional
            isFirstTimeUser: isFirstTimeUser,
            userCreatedAt: "2022-01-01T00:00:00Z", // Optional
            mixpanelDistinctId: "mixpanelDistinctId", // Optional - Mixpanel Distinct ID
            amplitudeDeviceId: "amplitudeDeviceId", // Optional - Amplitude Device ID
            posthogDistinctId: "posthogDistinctId" // Optional - PostHog Distinct ID
        )

        try await LinkrunnerSDK.shared.signup(
            userData: userData,
            additionalData: [:] // Optional: Any additional data
        )

        print("Signup successful")
    } catch {
        print("Error during signup:", error)
    }
}

```
```

--------------------------------

### Get Attribution Data

Source: https://docs.linkrunner.io/sdk/flutter/installation

Call this function to retrieve attribution data and deep link information for the current app installation. It prints the attribution data or any errors encountered.

```dart
Future<void> getAttributionInfo() async {
  try {
    final attributionData = await LinkRunner().getAttributionData();
    print('Attribution data: $attributionData');
  } catch (e) {
    print('Error getting attribution data: $e');
  }
}

```

--------------------------------

### Get Attributed Users - With All Parameters

Source: https://docs.linkrunner.io/api-reference/data-apis

A comprehensive request including campaign ID, start and end timestamps, timezone, page number, and limit. This allows for precise data retrieval.

```http
GET /attributed-users?display_id=XYZ123&start_timestamp=2025-06-23T10:29:26.074&end_timestamp=2025-06-24T10:29:26.074&timezone=America/New_York&page=3&limit=200
```

--------------------------------

### Get Attribution Data with Linkrunner

Source: https://docs.linkrunner.io/sdk/flutter

Retrieve attribution data and deep link information for the current installation using the `getAttributionData` function. This is essential for understanding campaign performance and user acquisition sources.

```dart
Future<void> getAttributionInfo() async {
  try {
    final attributionData = await LinkRunner().getAttributionData();
    print('Attribution data: $attributionData');
  } catch (e) {
    print('Error getting attribution data: $e');
  }
}
```

--------------------------------

### Retrieve GA4 Session ID in React Native

Source: https://docs.linkrunner.io/analytics-integrations/ga4

Use this JavaScript snippet to get the GA4 session ID using `@react-native-firebase/analytics` and pass it to the `linkrunner.signup` function. Ensure both libraries are installed and configured.

```javascript
import analytics from "@react-native-firebase/analytics";
import linkrunner from "rn-linkrunner";

const onSignup = async () => {
    try {
        const gaSessionId = await analytics().getSessionId();

        await linkrunner.signup({
            user_data: {
                id: "123", // Your user ID
                // ...other user fields
                ga_session_id: gaSessionId, // GA4 session ID
            },
            data: {},
        });
    } catch (error) {
        console.error("Error during signup with GA4 session ID:", error);
    }
};

```

--------------------------------

### User Signup and Identification with Linkrunner

Source: https://docs.linkrunner.io/sdk/flutter

Call the `signup` method to associate an install with a user ID. This is crucial for tracking user activity and reinstalls. It supports optional user details and integration-specific identifiers for platforms like Mixpanel, Amplitude, and PostHog.

```dart
Future<void> onSignup() async {
  try {
    await LinkRunner().signup(
      userData: LRUserData(
        id: '123', // Required: User ID
        name: 'John Doe', // Optional
        phone: '9876543210', // Optional
        email: 'user@example.com', // Optional
        // These properties are used to track reinstalls
        userCreatedAt: '2024-01-01T00:00:00Z', // Optional
        isFirstTimeUser: true, // Optional
        mixpanelDistinctId: 'mixpanelDistinctId', // Optional - Mixpanel Distinct ID
        amplitudeDeviceId: 'amplitudeDeviceId', // Optional - Amplitude User ID
        posthogDistinctId: 'posthogDistinctId', // Optional - PostHog Distinct ID
      ),
      data: {}, // Optional: Any additional data
    );
    print('Signup successful');
  } catch (e) {
    print('Error during signup: $e');
  }
}
```

--------------------------------

### Sign Up User with Linkrunner SDK

Source: https://docs.linkrunner.io/sdk/react-native

Call the `signup` method to tie installs and events to a user identifier. It's recommended to use the platform's identify function, but you can provide specific IDs for Mixpanel, PostHog, and Amplitude if needed.

```javascript
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);
    }
};
```

--------------------------------

### User Identification (signup)

Source: https://docs.linkrunner.io/sdk/react-native

Call the `signup` method as soon as the user is identified (signup or login) to tie the install and future events to a user identifier. It's recommended to use the platform's identify function or provide user identifiers for integrations like Mixpanel, PostHog, and Amplitude.

```APIDOC
## signup

### Description
Identifies a user and associates install events with their ID. This is crucial for tracking user activity from the moment they sign up or log in.

### Method
`signup(options)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **user_data** (object) - Required - Contains user identification details.
  - **id** (string) - Required - The unique identifier for the user.
  - **name** (string) - Optional - The user's full name.
  - **phone** (string) - Optional - The user's phone number.
  - **email** (string) - Optional - The user's email address.
  - **user_created_at** (string) - Optional - Timestamp indicating when the user was created (ISO 8601 format), used for tracking reinstalls.
  - **is_first_time_user** (boolean) - Optional - Flag indicating if this is the user's first time using the app, used for tracking reinstalls.
  - **mixpanel_distinct_id** (string) - Optional - Distinct ID for Mixpanel integration.
  - **amplitude_device_id** (string) - Optional - User ID for Amplitude integration.
  - **posthog_distinct_id** (string) - Optional - Distinct ID for PostHog integration.
- **data** (object) - Optional - Any additional custom data to be sent with the signup event.

### Request Example
```javascript
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
                user_created_at: "2024-01-01T00:00:00Z", // Optional
                is_first_time_user: true, // Optional
                mixpanel_distinct_id: "mixpanel_distinct_id", // Optional
                amplitude_device_id: "amplitude_device_id", // Optional
                posthog_distinct_id: "posthog_distinct_id", // Optional
            },
            data: {},
        });
        console.log("Signup successful");
    } catch (error) {
        console.error("Error during signup:", error);
    }
};
```

### Response
#### Success Response (200)
Indicates the signup operation was successful. No specific response body is detailed.

#### Response Example
None provided.
```

--------------------------------

### Install React Native SDK

Source: https://docs.linkrunner.io/quickstart

Use npm or yarn to add the React Native SDK to your project.

```bash
npm install rn-linkrunner
# or
yarn add rn-linkrunner
```

--------------------------------

### Install rn-linkrunner Package

Source: https://docs.linkrunner.io/sdk/react-native/installation

Install the Linkrunner SDK for React Native using npm or yarn.

```bash
# Using npm
npm install rn-linkrunner
```

```bash
# Using yarn
yarn add rn-linkrunner
```

--------------------------------

### Signup

Source: https://docs.linkrunner.io/sdk/unity

Initiates the user signup process. It takes user data and optional additional data, and provides a callback for success or error.

```APIDOC
## signup

### Description
Initiates the user signup process.

### Method Signature
`signup(userData, additionalData, callback)`

### Parameters
- **userData** (Object) - Required - User-specific data.
- **additionalData** (Object) - Optional - Additional data for signup.
- **callback** (LinkRunnerCallback<Void>) - Required - Callback to handle signup completion.
  - **onSuccess(Void result)**: Called when signup is successful.
  - **onError(String error)**: Called when signup fails.
```

--------------------------------

### Install Capacitor Linkrunner Package

Source: https://docs.linkrunner.io/sdk/capacitor

Install the Linkrunner package for Capacitor apps using npm or yarn.

```bash
npm install capacitor-linkrunner
```

```bash
yarn add capacitor-linkrunner
```

--------------------------------

### Identify the User

Source: https://docs.linkrunner.io/quickstart

Call `signup` once as soon as the user is identified (signup or login). This ties the install and future events to a user identifier, powering revenue and lifecycle attribution. `setUserData` is optional and should be called later when additional user details become available.

```APIDOC
## signup

### Description
Identifies a user and ties their activity to their install for attribution purposes.

### Method
`signup`

### Parameters
#### User Data
- **id** (string) - Required - Unique identifier for the user.
- **name** (string) - Optional - The user's name.
- **email** (string) - Optional - The user's email address.
- **phone** (string) - Optional - The user's phone number.
- **is_first_time_user** (boolean) - Optional - Indicates if this is the user's first time.

### Request Example (React Native)
```javascript
await linkrunner.signup({
    user_data: {
        id: "user_123",        // Required
        name: "Jane Doe",      // Optional
        email: "jane@example.com",
        phone: "9876543210",
        is_first_time_user: true,
    },
});
```

### Request Example (Flutter)
```dart
await LinkRunner().signup(
  userData: LRUserData(
    id: 'user_123',
    name: 'Jane Doe',
    email: 'jane@example.com',
  ),
);
```

### Request Example (iOS)
```swift
try await LinkrunnerSDK.shared.signup(
    userData: LinkrunnerUserData(
        id: "user_123",
        name: "Jane Doe",
        email: "jane@example.com"
    )
)
```

### Request Example (Android)
```kotlin
LinkRunner.getInstance().signup(
    userData = UserDataRequest(
        id = "user_123",
        name = "Jane Doe",
        email = "jane@example.com"
    )
)
```
```

--------------------------------

### Example Facebook App ID in strings.xml

Source: https://docs.linkrunner.io/features/meta-install-referrer

An example of how to define a Facebook App ID in your strings.xml file.

```xml
<string name="facebook_application_id" translatable="false">1234567890123456</string>
```

--------------------------------

### Initialize Linkrunner SDK in Unity

Source: https://docs.linkrunner.io/sdk/unity

Call this once at app startup to initialize the Linkrunner SDK. Obtain your token from the Linkrunner dashboard. This method is a no-op in the editor.

```csharp
public static void Initialize(string token, string secretKey = "", string keyId = "",
        bool disableIdfa = false, bool debug = false)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        Bridge.CallStatic("initialize", token, secretKey ?? "", keyId ?? "", debug);
#elif UNITY_IOS && !UNITY_EDITOR
        _LinkrunnerInitialize(token, secretKey, keyId, disableIdfa, debug);
#else
        Debug.Log("[Linkrunner] Initialize called (Editor — no-op)");
        OnInitialized?.Invoke(true, "editor");
#endif
    }
```

--------------------------------

### User Identification with Signup

Source: https://docs.linkrunner.io/sdk/flutter

Call the `signup` method to tie installs and events to a user identifier. This is crucial for tracking user activity across sessions and platforms.

```APIDOC
## 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](https://docs.mixpanel.com/docs/tracking-methods/id-management/identifying-users-simplified)
* [PostHog - How User Identification Works](https://posthog.com/docs/product-analytics/identify#how-identify-works)
* [Amplitude - Identify Users Documentation](https://amplitude.com/docs/get-started/identify-users)

If the platform's identifier function is not called, you must provide a user identifier for Mixpanel, PostHog, and Amplitude integration.

* mixpanelDistinctId for Mixpanel
* amplitudeDeviceId for Amplitude
* posthogDistinctId for PostHog

```dart theme={null}
Future<void> onSignup() async {
  try {
    await LinkRunner().signup(
      userData: LRUserData(
        id: '123', // Required: User ID
        name: 'John Doe', // Optional
        phone: '9876543210', // Optional
        email: 'user@example.com', // Optional
        // These properties are used to track reinstalls
        userCreatedAt: '2024-01-01T00:00:00Z', // Optional
        isFirstTimeUser: true, // Optional
        mixpanelDistinctId: 'mixpanelDistinctId', // Optional - Mixpanel Distinct ID
        amplitudeDeviceId: 'amplitudeDeviceId', // Optional - Amplitude User ID
        posthogDistinctId: 'posthogDistinctId', // Optional - PostHog Distinct ID
      ),
      data: {}, // Optional: Any additional data
    );
    print('Signup successful');
  } catch (e) {
    print('Error during signup: $e');
  }
}
```
```

--------------------------------

### User Identification

Source: https://docs.linkrunner.io/sdk/flutter/installation

Call the `signup` method as soon as the user is identified to tie install data and future events to a user identifier. This is crucial for attribution tracking.

```APIDOC
## User Identification

### Description
Calls the `signup` method to associate user identification data with the Linkrunner SDK. This is recommended to be called as soon as a user signs up or logs in, enabling Linkrunner to tie install data and future events to a specific user identifier. It also supports integrations with platforms like Mixpanel, PostHog, and Amplitude by allowing you to pass their respective distinct IDs.

### Method Signature
`Future<void> signup({required LRUserData userData, Map<String, dynamic>? data})`

### Parameters
*   **userData** (LRUserData) - Required - An object containing user identification details.
    *   **id** (string) - Required - The unique identifier for the user.
    *   **name** (string) - Optional - The user's name.
    *   **phone** (string) - Optional - The user's phone number.
    *   **email** (string) - Optional - The user's email address.
    *   **userCreatedAt** (string) - Optional - The timestamp when the user was created (ISO 8601 format).
    *   **isFirstTimeUser** (boolean) - Optional - Indicates if this is the user's first time.
    *   **mixpanelDistinctId** (string) - Optional - Distinct ID for Mixpanel integration.
    *   **amplitudeDeviceId** (string) - Optional - User ID for Amplitude integration.
    *   **posthogDistinctId** (string) - Optional - Distinct ID for PostHog integration.
*   **data** (Map<String, dynamic>) - Optional - Any additional custom data to send with the signup event.

### Request Example
```dart
Future<void> onSignup() async {
  try {
    await LinkRunner().signup(
      userData: LRUserData(
        id: '123', // Required: User ID
        name: 'John Doe', // Optional
        phone: '9876543210', // Optional
        email: 'user@example.com', // Optional
        // These properties are used to track reinstalls
        userCreatedAt: '2024-01-01T00:00:00Z', // Optional
        isFirstTimeUser: true, // Optional
        mixpanelDistinctId: 'mixpanelDistinctId', // Optional - Mixpanel Distinct ID
        amplitudeDeviceId: 'amplitudeDeviceId', // Optional - Amplitude User ID
        posthogDistinctId: 'posthogDistinctId', // Optional - PostHog Distinct ID
      ),
      data: {},
    );
    print('Signup successful');
  } catch (e) {
    print('Error during signup: $e');
  }
}
```
```

--------------------------------

### User Identification with signup

Source: https://docs.linkrunner.io/sdk/react-native/installation

Call the `signup` method as soon as the user is identified (signup or login) to tie the install and future events to a user identifier. It's recommended to use the platform's identify function or provide specific IDs for integrations like Mixpanel, PostHog, and Amplitude.

```APIDOC
## 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).

If the platform’s identifier function is not called, you must provide a user identifier for Mixpanel, PostHog, and Amplitude integration.

```javascript
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);
    }
};
```
```

--------------------------------

### Install Expo Linkrunner Packages

Source: https://docs.linkrunner.io/sdk/expo

Install both the React Native and Expo packages for Linkrunner integration. This is the first step in setting up the SDK.

```bash
npm install rn-linkrunner

npx expo install expo-linkrunner
```
Tokens:
Raw