> ## Documentation Index
> Fetch the complete documentation index at: https://docs.clix.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrate from Clix to Braze

> Replace the Clix SDK with Braze and rebuild push campaigns, audiences, and events.

<Warning>
  **Clix will shut down on November 30, 2026.**

  Complete your migration before this date to continue sending notifications.
  Preserve your campaign settings and reports before the service shuts down.

  If you would like to migrate to **Notifly**, email
  [support@clix.so](mailto:support@clix.so) for migration assistance.
</Warning>

<Warning>
  **Migration impact**

  * **Register devices with Braze.** Plan for users to open the updated app. Importing a profile alone does not make an installation ready for Braze push.
  * **Check token types.** Android uses FCM; the Braze Swift integration uses APNs. A Clix iOS FCM token is not an APNs token.
  * **Keep permissions and preferences.** Existing OS permission stays with the same installed app. Reapply marketing opt-outs and subscription rules.
  * **Rebuild automation and reporting.** Campaigns, Canvas flows, history, and users waiting in Clix campaigns do not transfer automatically.
</Warning>

This guide walks you through moving your Clix integration to Braze. Keep the same account identifiers, replace the SDK in an app release, and move campaign traffic after you verify device registration.

## Before Getting Started

* Create Android and iOS apps in your Braze workspace as needed.
* Get each app's **SDK API key** and the workspace's **SDK endpoint**. These differ from the REST API key and REST endpoint used by your backend.
* Keep the existing Android package name and iOS bundle identifier.
* Record Clix campaign definitions, account IDs, properties, events, notification handling, and opt-outs.

## Migration Steps

<Steps>
  <Step title="Configure push credentials">
    In Braze App Settings, configure Android FCM HTTP v1 credentials for your existing Firebase project. Configure iOS APNs credentials for your existing bundle identifier.

    Keep server-side credentials in the provider console or your backend. Use the SDK API key and SDK endpoint in the app. Follow [Braze SDK integration](https://www.braze.com/docs/developer_guide/sdk_integration) and [push setup](https://www.braze.com/docs/developer_guide/push_notifications) for your platform.
  </Step>

  <Step title="Replace Clix initialization and notification handling">
    Remove Clix initialization, notification configuration, permission calls, and listeners. Replace user and event calls in the next step.

    <AccordionGroup>
      <Accordion title="Remove platform-specific Clix integration">
        * **Android:** Remove `so.clix:clix-android-sdk` and its Clix-specific manifest entries. Keep your Firebase config and add any shared dependency that was previously supplied by Clix.
        * **iOS:** Remove the Clix package or pod. Replace `ClixAppDelegate` and replace `ClixNotificationServiceExtension` with the extension required by your selected Braze features.
        * **React Native:** Remove `@clix-so/react-native-sdk`, then follow Braze's React Native setup, including native configuration or your Expo integration.
        * **Flutter:** Remove `clix_flutter`, then follow Braze's Flutter setup and its native push configuration.

        Review app delegate forwarding and Android messaging services. Remove competing Clix handlers or implement Braze's documented custom-service routing so each payload is processed once.
      </Accordion>
    </AccordionGroup>

    <Tabs>
      <Tab title="Android">
        Add a pinned supported version in your app module, replacing `BRAZE_VERSION`:

        ```kotlin app/build.gradle.kts theme={null} theme={null}
        dependencies {
            implementation("com.braze:android-sdk-ui:BRAZE_VERSION")
        }
        ```

        Add your SDK credentials and Firebase sender ID:

        ```xml app/src/main/res/values/braze.xml theme={null} theme={null}
        <resources>
            <string name="com_braze_api_key">YOUR_BRAZE_SDK_API_KEY</string>
            <string name="com_braze_custom_endpoint">YOUR_BRAZE_SDK_ENDPOINT</string>
            <bool name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
            <string name="com_braze_firebase_cloud_messaging_sender_id">YOUR_FIREBASE_SENDER_ID</string>
        </resources>
        ```

        Register session lifecycle handling in your existing, manifest-registered `Application` class:

        ```kotlin MainApplication.kt theme={null} theme={null}
        import android.app.Application
        import com.braze.BrazeActivityLifecycleCallbackListener

        class MainApplication : Application() {
            override fun onCreate() {
                super.onCreate()
                registerActivityLifecycleCallbacks(
                    BrazeActivityLifecycleCallbackListener()
                )
            }
        }
        ```

        Keep Firebase Messaging and the Google Services plugin configured. Set notification channels and icons, and preserve your Android 13+ permission flow. Verify automatic FCM registration in Braze before sending a test.
      </Tab>

      <Tab title="iOS">
        Install the Braze Swift SDK and select `BrazeKit`. Keep a strong reference to the instance. In your app delegate's launch method:

        ```swift AppDelegate.swift theme={null} theme={null}
        import UIKit
        import BrazeKit

        class AppDelegate: UIResponder, UIApplicationDelegate {
            var braze: Braze?

            func application(
                _ application: UIApplication,
                didFinishLaunchingWithOptions launchOptions:
                    [UIApplication.LaunchOptionsKey: Any]?
            ) -> Bool {
                let configuration = Braze.Configuration(
                    apiKey: "YOUR_BRAZE_SDK_API_KEY",
                    endpoint: "YOUR_BRAZE_SDK_ENDPOINT"
                )
                configuration.push.automation = true
                braze = Braze(configuration: configuration)
                return true
            }
        }
        ```

        Complete APNs registration and notification authorization using the Swift push setup guide. Keep permission prompting at your existing point in the UI. Configure the Braze notification service extension for the rich push features you use, and restore any app behavior previously inherited from Clix.
      </Tab>
    </Tabs>

    Use Braze's platform-specific setup for a shared codebase rather than copying native initialization into the app twice.
  </Step>

  <Step title="Map user IDs, properties, and events">
    | Clix integration | Braze replacement |
    | - | - |
    | `Clix.setUserId()` | `changeUser()` with the same stable account ID as the external ID |
    | User properties | Standard Braze attributes or custom attributes |
    | `Clix.trackEvent()` | Custom events; preserve names and supported property types |
    | Campaign audiences | Segments and campaign or Canvas eligibility |
    | Device records | Braze app and device registration, separate from Clix IDs |

    ```kotlin UserIntegration.kt theme={null} theme={null}
    import com.braze.Braze
    import com.braze.models.outgoing.BrazeProperties

    val braze = Braze.getInstance(context)
    braze.changeUser("user_12345")
    braze.currentUser?.setCustomUserAttribute("plan", "premium")
    braze.logCustomEvent(
        "checkout_started",
        BrazeProperties().addProperty("cart_id", "cart_123")
    )
    ```

    Identify the restored authenticated account before sending account-specific events. Review standard attributes such as email and language rather than importing every Clix property as a custom attribute. Keep anonymous installations distinct until you have a verified account mapping.

    <Info>
      Logout behavior needs an explicit decision. Current Braze SDKs provide `logout()` and `unregisterPush()`; Android support starts at 43.0.0 and Swift at 18.0.0. Full logout disables the SDK after successful cleanup, so implement its documented re-enable and registration flow at the next login. Handle failures and retries. Do not use a shared placeholder account ID on logout. See [Braze user IDs and logout](https://www.braze.com/docs/developer_guide/analytics/setting_user_ids).
    </Info>

    Map your marketing preferences to the appropriate Braze subscription state and audience exclusions. OS authorization, token registration, and marketing consent are separate checks.
  </Step>

  <Step title="Recreate campaigns and backend integrations">
    Rebuild Clix scheduled campaigns as Braze campaigns and multi-step event flows as campaigns or Canvas flows. Review delays, re-entry, cancellation events, time zones, frequency caps, quiet hours, and user-versus-device targeting.

    Rewrite personalization using the destination's supported syntax and defaults. Recreate deep links, image attachments, action buttons, and categories. On Android, explicitly configure automatic deep-link handling if you want Braze to navigate on a tap; otherwise connect the callback to your existing navigation.

    Replace Clix sends with the appropriate Braze REST operation:

    * [Messages send](https://www.braze.com/docs/api/endpoints/messaging/send_messages/post_send_messages/) for server-composed messages.
    * [API-triggered campaign send](https://www.braze.com/docs/api/endpoints/messaging/send_messages/post_send_triggered_campaigns/) for campaigns configured in Braze.

    Use Braze identifiers and your workspace's REST endpoint. Rotate backend configuration and update webhook or export consumers. Import profile data while automation is paused; replaying old events can cause immediate campaign entry.

    Keep historical Clix metrics separately and establish a new reporting baseline. Delivery and attribution definitions can differ between providers.
  </Step>

  <Step title="Validate and move notification traffic">
    Upgrade an existing installation and confirm the expected external ID, push registration, properties, and one test message. Check Android FCM and iOS APNs separately.

    * Test foreground, background, cold-start taps, deep links, rich media, and actions.
    * Test denied permission, marketing opt-out, logout failures, re-login, account switching, and multiple devices.
    * Confirm custom events and test campaign entry without enabling production automation.

    Record successful Braze registration per installation. Exclude ready installations from Clix before enabling Braze sends. For campaigns that fan out to all devices for an external ID, use an account-level cutoff or tested device filtering so the two providers cannot overlap.

    Expand from a small release cohort after registration, delivery, and crash checks pass. Keep compatible old installations on Clix only until your cutoff, which must be before November 30, 2026. Archive the old campaigns and reports before the service shuts down. A replacement app without Clix handlers cannot rely on a backend-only rollback to Clix payloads.
  </Step>
</Steps>

## Push Token Migration

SDK registration is the default. If you have an authorized token export and want an assisted import, confirm Braze's supported import process, app mapping, token types, and payload compatibility before using it. Do not assume that importing user attributes also imports push eligibility.

Keep the Firebase project and app identity compatible where possible. Re-registering with Braze does not require resetting OS permission or deliberately rotating every token.

## Related Guides

<CardGroup cols={2}>
  <Card title="Clix Event Tracking" icon="chart-line" href="/event-tracking/event-tracking">
    Review the event names and property types used by your campaigns.
  </Card>

  <Card title="Clix Campaign Types" icon="calendar" href="/campaigns/types">
    Map existing automation to campaigns and Canvas flows.
  </Card>
</CardGroup>