// build.gradle.kts (app)
dependencies {
    implementation("com.vialink:sdk:1.0.0")
}

// Application.kt
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()

        ViaLinkSDK.init(this, "YOUR_API_KEY")
    }
}

// Register a deep link callback (SDK 3.1+: (DeepLinkData?) -> Unit)
// Always called once on handleIntent:
//   - data != null : App Link entry → route using data.path
//   - data == null : normal launch (icon tap etc.) → keep the default screen
ViaLinkSDK.onDeepLink { data ->
    if (data == null) {
        Log.d("ViaLink", "Normal launch — keep the default screen")
        return@onDeepLink
    }
    Log.d("ViaLink", "path: ${data.path}")
    Log.d("ViaLink", "params: ${data.params}")
}

// Deferred deep link callback (SDK 3.2+: called once on every app launch)
// - First launch: called as soon as the match result is decided, within 5s (error on timeout/failure)
// - Non-first launch: called immediately with (null, null) — no /v1/open call (same meaning as organic)
ViaLinkSDK.onDeferredDeepLink { data, error ->
    when {
        error != null -> Log.w("ViaLink", "Deferred match failed: ${error.code}")
        data == null  -> Log.d("ViaLink", "Organic or non-first launch — normal entry")
        else          -> Log.d("ViaLink", "Deferred: ${data.path}")
    }
}

// Handle the launch Intent in the Activity (SDK 3.1+: callback also fires on normal launches)
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ViaLinkSDK.handleIntent(intent)        // Always called
    }

    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        ViaLinkSDK.handleIntent(intent)
    }
}

// Purchase completed
ViaLinkSDK.track("purchase", mapOf(
    "product_id" to "12345",
    "revenue" to 29900,
    "currency" to "KRW"
))

// Sign up
ViaLinkSDK.track("signup")

// Add to cart
ViaLinkSDK.track("add_to_cart", mapOf("product_id" to "12345"))

import com.vialink.sdk.ViaLinkSDK
import com.vialink.sdk.model.PaymentInitiatedArgs
import kotlinx.coroutines.launch

// Right before showing the payment screen (inside a coroutine scope)
lifecycleScope.launch {
    try {
        val result = ViaLinkSDK.payment.initiated(
            PaymentInitiatedArgs(
                orderId = "ORD-2026-0001",
                amount = 19900.0,
                currency = "KRW",
                paymentMethod = "card",
                metadata = mapOf("productId" to "prod-001"),
            )
        )
        // result.success, result.paymentEventId
        Log.d("ViaLink", "payment_event_id=${result.paymentEventId}")
    } catch (e: IllegalArgumentException) {
        // Input validation failed (orderId format, amount, currency)
    } catch (e: Exception) {
        // Network error
    }
}

lifecycleScope.launch {
    val result = ViaLinkSDK.createLink(
        path = "/product/12345",
        data = mapOf("promo_code" to "FRIEND_SHARE"),
        campaign = "referral",
        linkType = "dynamic", // "dynamic" when you need click tracking (omit for "static")
        iosUrl = "https://apps.apple.com/app/id123456",
        androidUrl = "https://play.google.com/store/apps/details?id=com.example",
        webUrl = "https://www.example.com/product/12345",
        ogTitle = "Summer Sale",
        ogDescription = "Check it out now!",
        ogImageUrl = "https://cdn.example.com/promo.jpg",
        channel = "email",
        feature = "product_share",
        tags = listOf("summer", "sale"),
        expiresAt = "2026-12-31T23:59:59Z"
    )

    result.onSuccess { shortUrl ->
        // shortUrl: "https://vialink.app/{your-slug}/xYz12"
        val sendIntent = Intent().apply {
            action = Intent.ACTION_SEND
            putExtra(Intent.EXTRA_TEXT, shortUrl)
            type = "text/plain"
        }
        startActivity(Intent.createChooser(sendIntent, "Share"))
    }
}

import com.vialink.sdk.ViaLinkSDK;
import com.vialink.sdk.model.CreateLinkOptions;
import java.util.Map;
import java.util.List;

// Full options — using the CreateLinkOptions Builder (Callback)
CreateLinkOptions opts = new CreateLinkOptions.Builder()
    .data(Map.of("promo_code", "FRIEND_SHARE"))
    .campaign("referral")
    .linkType("dynamic")
    .iosUrl("https://apps.apple.com/app/id123456")
    .androidUrl("https://play.google.com/store/apps/details?id=com.example")
    .webUrl("https://www.example.com/product/12345")
    .ogTitle("Summer Sale")
    .ogImageUrl("https://cdn.example.com/promo.jpg")
    .channel("email")
    .feature("product_share")
    .tags(List.of("summer", "sale"))
    .expiresAt("2026-12-31T23:59:59Z")
    .build();
ViaLinkSDK.createLinkAsync(
    "/product/12345",
    opts,
    shortUrl -> { /* success (main thread) */ },
    err -> Log.e("ViaLink", "Failed to create link", err)
);

// CompletableFuture style (minSdk 24+)
ViaLinkSDK.createLinkFuture("/product/12345", opts)
    .thenAccept(shortUrl -> { /* success */ })
    .exceptionally(err -> { /* failure */ return null; });

// Simple call — when you don't need fallback/OG options
ViaLinkSDK.createLinkAsync(
    "/product/12345",
    Map.of("promo_code", "FRIEND_SHARE"),
    "referral",
    "dynamic",
    shortUrl -> {},
    err -> {}
);

<activity
    android:name=".MainActivity"
    android:exported="true">

    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="https"
            android:host="vialink.app"

            android:pathPrefix="/{your-slug}/" />
    </intent-filter>
</activity>

Xcode > File > Add Package Dependencies
URL: https://github.com/aresjoydev/vialink-ios-sdk

import ViaLinkCore

// AppDelegate
func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions ...) -> Bool {
    ViaLinkSDK.shared.configure(apiKey: "YOUR_API_KEY")
    return true
}

// Or SwiftUI App
@main
struct MyApp: App {
    init() {
        ViaLinkSDK.shared.configure(apiKey: "YOUR_API_KEY")
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
                .onOpenURL { url in
                    ViaLinkSDK.shared.handleURL(url)
                }
        }
    }
}

// Register a deep link callback (SDK 3.1+: (DeepLinkData?) -> Void)
// Always called once when notified of app entry:
//   - data != nil : Universal Link entry → route using data.path
//   - data == nil : normal launch (icon tap etc.) → keep the default screen
ViaLinkSDK.shared.onDeepLink { data in
    guard let data = data else {
        print("Normal launch — keep the default screen")
        return
    }
    print("path: \(data.path)")
    print("params: \(data.params)")
}

// Deferred deep link callback (SDK 3.2+: called once on every app launch)
// - First launch: called as soon as the match result is decided, within 5s (error on timeout/failure)
// - Non-first launch: called immediately with (nil, nil) — no /v1/open call (same meaning as organic)
ViaLinkSDK.shared.onDeferredDeepLink { data, error in
    if let error = error {
        print("Deferred match failed: \(error.code.rawValue)")
    } else if let data = data {
        print("Deferred: \(data.path)")
    } else {
        print("Organic or non-first launch — normal entry")
    }
}

// Handle Universal Links + normal-launch notification in SceneDelegate (3.1+)
func scene(_ scene: UIScene,
           willConnectTo session: UISceneSession,
           options: UIScene.ConnectionOptions) {
    if let activity = options.userActivities.first {
        ViaLinkSDK.shared.handleUniversalLink(activity)
    } else if let urlContext = options.urlContexts.first {
        ViaLinkSDK.shared.handleURL(urlContext.url)
    } else {
        ViaLinkSDK.shared.notifyAppLaunch()        // Normal launch
    }
}

func scene(_ scene: UIScene,
           continue userActivity: NSUserActivity) {
    ViaLinkSDK.shared.handleUniversalLink(userActivity)
}

// Purchase completed
ViaLinkSDK.shared.track("purchase", data: [
    "product_id": "12345",
    "revenue": "29900",
    "currency": "KRW"
])

// Sign up
ViaLinkSDK.shared.track("signup")

import ViaLinkCore

// Right before showing the payment screen (inside an async context)
Task {
    do {
        let result = try await ViaLinkSDK.shared.payment.initiated(
            PaymentInitiatedArgs(
                orderId: "ORD-2026-0001",
                amount: 19900,
                currency: "KRW",
                paymentMethod: "card",
                metadata: ["productId": "prod-001"]
            )
        )
        print("payment_event_id=\(result.paymentEventId)")
    } catch let error as PaymentError {
        // .invalidOrderId / .invalidAmount / .invalidCurrency / .sdkNotInitialized / .networkFailure
    } catch {
        // Other errors
    }
}

let shortUrl = try await ViaLinkSDK.shared.createLink(
    path: "/product/12345",
    data: ["promo_code": "FRIEND_SHARE"],
    campaign: "referral",
    linkType: "dynamic", // "dynamic" when you need click tracking (omit for "static")
    iosUrl: "https://apps.apple.com/app/id123456",
    androidUrl: "https://play.google.com/store/apps/details?id=com.example",
    webUrl: "https://www.example.com/product/12345",
    ogTitle: "Summer Sale",
    ogDescription: "Check it out now!",
    ogImageUrl: "https://cdn.example.com/promo.jpg",
    channel: "email",
    feature: "product_share",
    tags: ["summer", "sale"],
    expiresAt: "2026-12-31T23:59:59Z"
)
// shortUrl: "https://vialink.app/{your-slug}/xYz12"

let activityVC = UIActivityViewController(
    activityItems: [shortUrl],
    applicationActivities: nil
)
present(activityVC, animated: true)

1. Xcode > Target > Signing & Capabilities
2. + Capability > Associated Domains
3. Add domain: applinks:vialink.app

npm install vialink-web-sdk

import { ViaLinkWebSDK } from 'vialink-web-sdk';

const sdk = ViaLinkWebSDK.init({
  apiKey: 'YOUR_API_KEY'
});

// Callback pattern (SDK 3.1+: parses the current URL once immediately on registration)
//   - data != null : ViaLink deep link format entry → route using data.path
//   - data == null : normal entry (landing page etc.) → keep the default route
sdk.onDeepLink((data) => {
  if (!data) {
    console.log('Normal entry — keep the default route');
    return;
  }
  console.log('path:', data.path);
  console.log('params:', data.params);
  // window.location.href = data.path or router navigate
});

// Synchronous extraction pattern (immediately at page load time)
const data = sdk.getDeepLinkData();
if (data) {
  console.log('shortCode:', data.shortCode);
}

// Parse an arbitrary URL using the static method
const parsed = ViaLinkWebSDK.parseDeepLinkFromURL(
  'https://vialink.app/{your-slug}/xYz12?ref=share'
);

// Purchase completed
sdk.track('purchase', {
  product_id: '12345',
  revenue: 29900,
  currency: 'KRW'
});

// Signup completed (non-payment conversion — aggregated in the Events tab)
sdk.track('signup_completed');

// Flush immediately
await sdk.flush();

// Recommended event names — for Events tab analytics
sdk.track('signup_completed');                     // Signup completed
sdk.track('lead_submitted', { form: 'consult' });  // Consultation/inquiry submitted
sdk.track('trial_started');                        // Free trial started

// For partner attribution — capture (store) vlref on landing, then
// call POST /v1/conversions from the backend once the conversion is confirmed (pass as referral_key)
const vlref = new URLSearchParams(location.search).get('vlref');
if (vlref) sessionStorage.setItem('vialink_ref', vlref);

import { ViaLinkWebSDK } from 'vialink-web-sdk';

ViaLinkWebSDK.init({ apiKey: 'YOUR_API_KEY' });

// Right before showing the payment screen:
try {
  const result = await ViaLinkWebSDK.payment.initiated({
    orderId: 'ORD-2026-0001',
    amount: 19900,
    currency: 'KRW',
    paymentMethod: 'card',
    metadata: { productId: 'prod-001' },
  });
  console.log('payment_event_id=', result.paymentEventId);
} catch (e) {
  // Input validation failed or network error
  console.error(e);
}

const shortUrl = await sdk.createLink(
  '/product/12345',
  { promo_code: 'FRIEND_SHARE' },
  'referral',
  'dynamic', // "dynamic" when you need click tracking (omit for 'static')
  {
    iosUrl: 'https://apps.apple.com/app/id123456',
    androidUrl: 'https://play.google.com/store/apps/details?id=com.example',
    webUrl: 'https://www.example.com/product/12345',
    ogTitle: 'Summer Sale',
    ogDescription: 'Check it out now!',
    ogImageUrl: 'https://cdn.example.com/promo.jpg',
    channel: 'email',
    feature: 'product_share',
    tags: ['summer', 'sale'],
    expiresAt: '2026-12-31T23:59:59Z',
  }
);
console.log(shortUrl); // "https://vialink.app/{your-slug}/xYz12"

sdk.showBanner({
  title: 'View in App',
  description: 'Use the app for a faster experience',
  buttonText: 'Open',
  iosStoreUrl: 'https://apps.apple.com/app/id123456',
  androidStoreUrl: 'https://play.google.com/store/apps/...',
  position: 'bottom',
  theme: 'light'
});

// Hide the banner
sdk.hideBanner();

npm install vialink-react-native-sdk
# or
yarn add vialink-react-native-sdk

import { ViaLinkSDK } from 'vialink-react-native-sdk';

// App.tsx
function App() {
  useEffect(() => {
    ViaLinkSDK.shared.configure('YOUR_API_KEY');

    return () => {
      ViaLinkSDK.shared.destroy();
    };
  }, []);

  return <Navigation />;
}

// Register a deep link callback (SDK 3.1+: (data: DeepLinkData | null) => void)
// Always called once when notified of native app entry:
//   - data != null : App Links / Universal Links entry → route using data.path
//   - data == null : normal entry (icon tap etc.) → keep the default route
ViaLinkSDK.shared.onDeepLink((data) => {
  if (!data) {
    console.log('Normal entry — keep the default route');
    return;
  }
  console.log('path:', data.path);
  console.log('params:', data.params);
  navigation.navigate(data.path, data.params);
});

// Deferred deep link callback (SDK 3.2+: called once on every app launch)
// - First launch: /v1/open match result delivered within 5s (error on timeout/failure)
// - Non-first launch: called immediately with (null, null) — no network call (same meaning as organic)
ViaLinkSDK.shared.onDeferredDeepLink((data, error) => {
  if (error) {
    console.warn('Deferred match failed:', error.code);
    return;
  }
  if (!data) {
    console.log('Organic or non-first launch — normal entry');
    return;
  }
  navigation.navigate(data.path, data.params);
});

// Purchase completed
ViaLinkSDK.shared.track('purchase', {
  product_id: '12345',
  revenue: 29900,
  currency: 'KRW'
});

// Sign up
ViaLinkSDK.shared.track('signup');

import { ViaLinkSDK } from 'vialink-react-native-sdk';

// Right before showing the payment screen:
try {
  const result = await ViaLinkSDK.shared.payment.initiated({
    orderId: 'ORD-2026-0001',
    amount: 19900,
    currency: 'KRW',
    paymentMethod: 'card',
  });
  console.log('payment_event_id=', result.paymentEventId);
} catch (e) {
  // Input validation failed or network error
}

const shortUrl = await ViaLinkSDK.shared.createLink(
  '/product/12345',
  { promo_code: 'FRIEND_SHARE' },
  'referral',
  'dynamic', // "dynamic" when you need click tracking (omit for 'static')
  {
    iosUrl: 'https://apps.apple.com/app/id123456',
    androidUrl: 'https://play.google.com/store/apps/details?id=com.example',
    webUrl: 'https://www.example.com/product/12345',
    ogTitle: 'Summer Sale',
    ogImageUrl: 'https://cdn.example.com/promo.jpg',
    channel: 'sms',
    feature: 'product_share',
    tags: ['summer', 'sale'],
    expiresAt: '2026-12-31T23:59:59Z',
  }
);

await Share.share({ message: shortUrl });

// app.json (Expo)
{
  "expo": {
    "ios": {
      "associatedDomains": ["applinks:vialink.app"]
    },
    "android": {
      "intentFilters": [{
        "action": "VIEW",
        "autoVerify": true,
        "data": [{
          "scheme": "https",
          "host": "vialink.app",
          "pathPrefix": "/{your-slug}/"
        }],
        "category": ["BROWSABLE", "DEFAULT"]
      }]
    }
  }
}

Window > Package Manager > + > Add package from git URL:
https://github.com/aresjoydev/vialink-unity-sdk.git

using ViaLink;

public class GameManager : MonoBehaviour
{
    void Start()
    {
        ViaLinkSDK.Instance.Initialize("YOUR_API_KEY");
    }
}

// Deep link callback (SDK 3.1+: also fires on normal launches — data == null)
ViaLinkSDK.Instance.OnDeepLink += (data) =>
{
    if (data == null)
    {
        Debug.Log("Normal launch — keep the default screen");
        return;
    }
    Debug.Log($"path: {data.Path}");
    Debug.Log($"params: {data.Params}");
    SceneManager.LoadScene(data.Path);
};

// Deferred deep link callback (SDK 3.2+: fires once on every app launch)
// - First launch: /v1/open match result delivered within 5s (error on timeout/failure)
// - Non-first launch: called immediately with (null, null) — no network call (same meaning as organic)
ViaLinkSDK.Instance.OnDeferredDeepLink += (data, error) =>
{
    if (error != null)
    {
        Debug.LogWarning($"Deferred match failed: {error.Code}");
        return;
    }
    if (data == null)
    {
        Debug.Log("Organic or non-first launch — normal entry");
        return;
    }
    Debug.Log($"Deferred deep link: {data.Path}");
    SceneManager.LoadScene(data.Path);
};

// In-app purchase
ViaLinkSDK.Instance.TrackEvent("purchase",
    new Dictionary<string, object>
    {
        { "product_id", "gem_pack_100" },
        { "revenue", 4900 },
        { "currency", "KRW" }
    });

// Level cleared
ViaLinkSDK.Instance.TrackEvent("level_clear",
    new Dictionary<string, object>
    {
        { "level", 10 }
    });

using ViaLink.SDK;

// Right before showing the payment screen (inside a MonoBehaviour)
ViaLinkSDK.Payment.Initiated(
    new PaymentInitiatedArgs {
        OrderId = "ORD-2026-0001",
        Amount = 19900,
        Currency = "KRW",
        PaymentMethod = "card",
    },
    onSuccess: (result) => {
        Debug.Log($"payment_event_id={result.PaymentEventId}");
    },
    onError: (error) => {
        Debug.LogError($"Payment attempt failed: {error}");
    }
);

ViaLinkSDK.Instance.CreateLink(
    path: "/invite",
    data: new Dictionary<string, object>
    {
        { "inviter_id", PlayerId },
        { "reward", "gem_50" }
    },
    campaign: "friend_invite",
    linkType: "dynamic", // "dynamic" when you need click tracking (omit for "static")
    iosUrl: "https://apps.apple.com/app/id123456",
    androidUrl: "https://play.google.com/store/apps/details?id=com.example",
    webUrl: "https://www.example.com/invite",
    ogTitle: "Invite a Friend — Get a Reward",
    ogImageUrl: "https://cdn.example.com/invite.jpg",
    channel: "in_game",
    feature: "friend_invite",
    tags: new List<string> { "invite", "viral" },
    expiresAt: "2026-12-31T23:59:59Z",
    onSuccess: (shortUrl) =>
    {
        // shortUrl: "https://vialink.app/{your-slug}/xYz12"
        GUIUtility.systemCopyBuffer = shortUrl;
        ShowToast("Invite link copied!");
    },
    onError: (error) =>
    {
        Debug.LogError($"Failed to create link: {error}");
    }
);

flutter pub add vialink_flutter_plugin

import 'package:vialink_flutter_plugin/vialink_flutter_plugin.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await ViaLinkSDK.instance.configure(apiKey: 'YOUR_API_KEY');

  runApp(const MyApp());
}

// Deep link callback (SDK 3.1+: (DeepLinkData?) -> void)
// Always called once when notified of app entry:
//   - data != null : App Links / Universal Links entry → route using data.path
//   - data == null : normal entry (icon tap etc.) → keep the default route
ViaLinkSDK.instance.onDeepLink((data) {
  if (data == null) {
    print('Normal entry — keep the default route');
    return;
  }
  print('path: ${data.path}');
  print('params: ${data.params}');
  Navigator.pushNamed(context, data.path,
      arguments: data.params);
});

// Deferred deep link callback (SDK 3.2+: called once on every app launch)
// - First launch: /v1/open match result delivered within 5s (error on timeout/failure)
// - Non-first launch: called immediately with (null, null) — no network call (same meaning as organic)
ViaLinkSDK.instance.onDeferredDeepLink((data, error) {
  if (error != null) {
    debugPrint('Deferred match failed: ${error.code}');
    return;
  }
  if (data == null) {
    debugPrint('Organic or non-first launch — normal entry');
    return;
  }
  Navigator.pushNamed(context, data.path, arguments: data.params);
});

// Purchase completed
ViaLinkSDK.instance.track('purchase', data: {
  'product_id': '12345',
  'revenue': 29900,
  'currency': 'KRW',
});

// Sign up
ViaLinkSDK.instance.track('signup');

import 'package:vialink_flutter_plugin/vialink_flutter_plugin.dart';

// Right before showing the payment screen:
try {
  final result = await ViaLinkSDK.instance.payment.initiated(
    PaymentInitiatedArgs(
      orderId: 'ORD-2026-0001',
      amount: 19900,
      currency: 'KRW',
      paymentMethod: 'card',
      metadata: {'productId': 'prod-001'},
    ),
  );
  print('payment_event_id=${result.paymentEventId}');
} on ArgumentError catch (e) {
  // Input validation failed
  print(e);
} catch (e) {
  // PlatformException or other errors
}

final shortUrl = await ViaLinkSDK.instance.createLink(
  path: '/product/12345',
  data: {'promo_code': 'FRIEND_SHARE'},
  campaign: 'referral',
  linkType: 'dynamic', // "dynamic" when you need click tracking (omit for 'static')
  iosUrl: 'https://apps.apple.com/app/id123456',
  androidUrl: 'https://play.google.com/store/apps/details?id=com.example',
  webUrl: 'https://www.example.com/product/12345',
  ogTitle: 'Summer Sale',
  ogDescription: 'Check it out now!',
  ogImageUrl: 'https://cdn.example.com/promo.jpg',
  channel: 'email',
  feature: 'product_share',
  tags: ['summer', 'sale'],
  expiresAt: '2026-12-31T23:59:59Z',
);
// shortUrl: "https://vialink.app/{your-slug}/xYz12"

await Share.share(shortUrl);

# iOS: ios/Runner/Runner.entitlements
# Add Associated Domains:
#   applinks:vialink.app

# Android: android/app/src/main/AndroidManifest.xml
# <intent-filter android:autoVerify="true">
#   <action android:name="android.intent.action.VIEW" />
#   <category android:name="android.intent.category.DEFAULT" />
#   <category android:name="android.intent.category.BROWSABLE" />
#   <data
#     android:scheme="https"
#     android:host="vialink.app"
#     android:pathPrefix="/{your-slug}/" />
# </intent-filter>