> ## 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 Customer.io

> Replace the Clix SDK with Customer.io and rebuild mobile push campaigns around identified people.

<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 and identify users.** Users need to open the updated app, and the SDK must identify a person before Customer.io can target mobile push to them.
  * **Choose the iOS transport.** Customer.io supports APNs and FCM integrations. Clix's FCM tokens cannot be used in an APNs integration.
  * **Keep permissions and opt-outs.** The same installed app retains notification permission; messaging preferences must be carried over separately.
  * **Rebuild campaigns and reporting.** Segments, workflows, templates, and campaign history do not transfer automatically.
</Warning>

This guide walks you through replacing Clix with Customer.io's mobile SDKs. Preserve your account IDs, reconnect profile and event data, and move push campaigns after you verify device registration.

## Before Getting Started

* Create or select your Customer.io workspace and confirm its region.
* Add mobile SDK connections for the platforms you use and get their **CDP API keys**.
* Keep the existing Android package name and iOS bundle identifier.
* Record your Clix campaigns, account IDs, user properties, event schema, push handlers, and messaging preferences.

<Info>
  A CDP API key is used for the current SDK integration. It is different from a
  server-side App API key or legacy Track API credentials. A first-time Clix
  migration does not need `migrationSiteId`; that option is for upgrading an
  existing Customer.io integration.
</Info>

## Migration Steps

<Steps>
  <Step title="Configure mobile push delivery">
    Configure FCM credentials for Android in your workspace. Reuse the Firebase project already configured for your Clix app when possible.

    For iOS, choose one transport:

    * **FCM:** Keep Firebase Messaging and configure the Customer.io FCM integration for your existing Firebase project.
    * **APNs:** Configure APNs credentials and collect APNs tokens using the Customer.io APNs module.

    Do not register the same installation through both transports unless you have a deliberate, tested design. Follow the destination's [mobile SDK guides](https://docs.customer.io/integrations/sdk/) and push credential instructions for your selected transport.
  </Step>

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

    <AccordionGroup>
      <Accordion title="Remove platform-specific Clix integration">
        * **Android:** Remove `so.clix:clix-android-sdk` and Clix-specific manifest entries. Keep Firebase configuration and required shared dependencies.
        * **iOS:** Remove the Clix package or pod. Replace `ClixAppDelegate` and replace its notification service extension with the appropriate Customer.io integration.
        * **React Native:** Remove `@clix-so/react-native-sdk`, then use the Customer.io React Native SDK and its native or Expo configuration.
        * **Flutter:** Remove `clix_flutter`, then use the Customer.io Flutter SDK and its native push setup.

        Preserve dependencies used by other app features. Review any custom Android messaging service and iOS delegates so they forward destination payloads and registration updates correctly.
      </Accordion>
    </AccordionGroup>

    <Tabs>
      <Tab title="Android">
        Use the current 4.x module structure. Replace `CUSTOMER_IO_VERSION` with one pinned supported version for both modules:

        ```kotlin app/build.gradle.kts theme={null} theme={null}
        dependencies {
            implementation("io.customer.android:datapipelines:CUSTOMER_IO_VERSION")
            implementation("io.customer.android:messaging-push-fcm:CUSTOMER_IO_VERSION")
        }
        ```

        Initialize in your existing, manifest-registered `Application` class:

        ```kotlin MainApplication.kt theme={null} theme={null}
        import android.app.Application
        import io.customer.messagingpush.ModuleMessagingPushFCM
        import io.customer.sdk.CustomerIO
        import io.customer.sdk.CustomerIOConfigBuilder
        import io.customer.sdk.data.model.Region

        class MainApplication : Application() {
            override fun onCreate() {
                super.onCreate()
                val configuration = CustomerIOConfigBuilder(
                    applicationContext,
                    "YOUR_CUSTOMER_IO_CDP_API_KEY"
                )
                    .region(Region.US)
                    .addCustomerIOModule(ModuleMessagingPushFCM())
                    .build()
                CustomerIO.initialize(configuration)
            }
        }
        ```

        Change `Region.US` to `Region.EU` if required by your workspace. Keep the Google Services plugin and Firebase configuration. Preserve Android 13+ permission prompting, and verify notification channels and icons.

        If you retain a custom `FirebaseMessagingService`, forward messages and token updates using `CustomerIOFirebaseMessagingService` as described in the [Android push guide](https://docs.customer.io/integrations/sdk/android/push/push/). Do not leave Clix as a competing message consumer.
      </Tab>

      <Tab title="iOS">
        Follow the [iOS quick start](https://docs.customer.io/integrations/sdk/ios/quick-start-guide/) to install Data Pipelines and your chosen push module. Replace the Clix delegate integration with the documented `CioAppDelegateWrapper` setup.

        For an APNs integration, initialize in your app delegate's launch method:

        ```swift AppDelegate.swift theme={null} theme={null}
        import CioDataPipelines
        import CioMessagingPushAPN

        let configuration = SDKConfigBuilder(
            cdpApiKey: "YOUR_CUSTOMER_IO_CDP_API_KEY"
        ).build()
        CustomerIO.initialize(withConfig: configuration)
        MessagingPushAPN.initialize(
            withConfig: MessagingPushConfigBuilder().build()
        )
        ```

        Configure the workspace region, APNs registration, notification authorization, and the destination notification service extension using the linked setup guide.

        For FCM, use `CioMessagingPushFCM` and the required `CioFirebaseWrapper` package instead. Current documentation distributes the Firebase wrapper separately. Follow the [iOS push guide](https://docs.customer.io/integrations/sdk/ios/push/push-setup/) for registration and forwarding; do not mix APNs-module and FCM-module initialization.
      </Tab>
    </Tabs>

    Check the current [Android quick start](https://docs.customer.io/integrations/sdk/android/quick-start-guide/) when selecting SDK versions. For shared codebases, use the [React Native](https://docs.customer.io/integrations/sdk/react-native/) or [Flutter](https://docs.customer.io/integrations/sdk/flutter/) integration rather than a second native initialization.
  </Step>

  <Step title="Identify people and move events">
    | Clix integration | Customer.io replacement |
    | - | - |
    | `Clix.setUserId()` | `identify()` using the same stable account ID |
    | User properties | Profile traits or attributes |
    | `Clix.trackEvent()` | `track()` with the original event name and supported properties |
    | Device record | Device associated with an identified person |
    | Logout | `clearIdentify()` |

    ```kotlin UserIntegration.kt theme={null} theme={null}
    import io.customer.sdk.CustomerIO

    CustomerIO.instance().identify(
        userId = "user_12345",
        traits = mapOf("plan" to "premium", "language" to "en")
    )
    CustomerIO.instance().track(
        name = "checkout_started",
        properties = mapOf("cart_id" to "cart_123", "item_count" to 2)
    )

    // On logout
    CustomerIO.instance().clearIdentify()
    ```

    Call `identify()` after login and when restoring an authenticated session. Confirm the device appears on the intended person before enabling sends. If your Clix campaigns target anonymous users, redesign that flow for Customer.io's mobile push identification requirements rather than assigning all anonymous devices one shared ID.

    Carry over profile and messaging preferences from your app or backend. Validate [identification and device association](https://docs.customer.io/integrations/sdk/android/tracking/identify/) during logout and account switching. Keep event names, timestamps, and property types consistent with your new campaign triggers.
  </Step>

  <Step title="Rebuild campaigns and server integrations">
    Recreate segments and campaigns in Customer.io. Check trigger events, filters, delays, cancellation conditions, re-entry, user time zones, frequency limits, and quiet hours.

    Rewrite personalization for Customer.io's supported template syntax. Replace Clix landing URL handling with the chosen Customer.io click behavior and your navigation code. Rebuild images, action handling, and iOS extension configuration for the destination payload.

    Replace Clix backend requests with the appropriate [Customer.io APIs](https://docs.customer.io/integrations/api/). Choose between tracking events that enter a workflow and sending a configured transactional message. Use the correct API credentials and region-specific endpoints; a Clix campaign ID has no meaning in Customer.io.

    Import profiles while production workflows are paused. Do not replay historical events into active campaigns without a plan for duplicate triggers. Update webhook consumers and keep historical Clix metrics separately.
  </Step>

  <Step title="Test and release gradually">
    Upgrade an existing installation and confirm its person ID, device registration, profile traits, and one test push. Test each selected iOS transport separately from Android.

    * Check foreground, background, and cold-start taps, including deep links and rich media.
    * Check denied permission, marketing opt-out, anonymous use, logout, account switching, and multiple devices.
    * Confirm event-driven campaign entry and delivery or open metrics without double-counting custom callbacks.

    Store destination readiness per installation and person. Exclude migrated installations from Clix before enabling Customer.io sends. If a campaign targets every device on a person, use a tested account-level cutoff or supported device filtering to avoid overlap.

    Start with a small release cohort and expand after registration and delivery checks pass. Keep compatible old installations on Clix only until your cutoff, which must be before November 30, 2026. A new app without Clix handlers needs a compatible rollback send path or a corrective app update.
  </Step>
</Steps>

## Push Token Migration

The default is to let the SDK register the current device and associate it with an identified person. An authorized token export can help only if the destination's import path supports the token type, credentials, and app payload. Confirm those requirements before importing.

Keeping the same Firebase project may preserve compatible FCM tokens. Switching iOS to APNs requires APNs registration, not conversion of Clix FCM tokens. Neither path requires resetting OS notification permission.

## Related Guides

<CardGroup cols={2}>
  <Card title="Clix User Management" icon="circle-user" href="/user-management/user-management">
    Review account IDs and anonymous-user behavior before identifying people.
  </Card>

  <Card title="Clix Event Tracking" icon="chart-line" href="/event-tracking/event-tracking">
    Map your current events to Customer.io campaign triggers.
  </Card>
</CardGroup>