strat:swift

Liveplugins are JavaScript code snippets published to your Segment workspace and then downloaded directly to the mobile devices of end users. Live plugins letyouperform real-time modifications to events before theyleave themobiledevice.

LivePlugins let you modify analytics events in real time, directly on user devices, without rebuilding or redeploying your app. They’re JavaScript snippets thatyoupublish from your Segment workspace, where theyrun on your users’mobiledevices to filter or transform data before it’s sent to Segment.

On this page, you'll learn howtoset up live plugins and how to createyourown live plugins. You'll also see example live plugins that address common use cases.

Live Plugins work alongside[Auto-Instrumentation](/docs/connections/auto-instrumentation/)togive you flexible control overyourevent data.

On this page, you’ll learn how to set up your mobile app to support Live Plugins, create and deploy custom plugins, and explore examples for common use cases.

Because live plugins let you modify event data before it leaves a mobile device, you can use the same function to modify data meant for all your cloud-mode and device-mode destinations.

You can use JavaScript Live Plugins with Analytics-Swift and Analytics-Kotlin to modify or filter event data directly on user devices. This lets you make real-time updates to your tracking logic without redeploying your app, helping you maintain data quality and consistency across your mobile users.

Because Live Plugins run before data leaves the device, you can apply the same logic to all destinations or target specific destinations as needed.

To uselive plugins, you first need to set up your mobile app with a one-time configuration.

To useLive Plugins, you first need to set up your mobile app with a one-time configuration.

To configurelive plugins:

To configureLive Plugins:

1. Includethe[AnalyticsLive for Swift plugin](https://github.com/segment-integrations/analytics-swift-live){:target="_blank"}

and[AnalyticsLive for Kotlin plugin](https://github.com/segment-integrations/analytics-kotlin-live){:target="_blank"}

1. Include[Analytics-Live for Swift plugin](https://github.com/segment-integrations/analytics-swift-live){:target="_blank"}

and[Analytics-Live for Kotlin](https://github.com/segment-integrations/analytics-kotlin-live){:target="_blank"}

in your project.

2. Add the plugin to your instance of Analytics, using the following code:

{% endcodeexampletab %}

{% endcodeexample %}

After you've completed setup, you can deploy your apps to the Apple App Store and Google Play Store. You can then add new JavaScript plugin code to your mobile apps through the CLI and perform updates as often as needed.

This section walks you through a sample live plugin implementation.

Copy and save the following file, which anonymizes events by removing user IDs and device IDs:

classPrivacyLivePluginextendsLivePlugin {

execute(event) {

event.userId=null;

deleteevent.context.device.id;

returnevent;

}

}

Note the name of your saved file. You'll need it in the next step.

With your plugin saved, you'll next deploy the plugin with Segment's Live Plugin CLI. Follow these steps:

Run this command to install the Segment CLI:

$ brew install segment-integrations/formulae/segmentcli

Next, you'll authenticate with Segment to give the CLI access to your workspace:

1. Within your Segment workspace, navigate to**Settings > Workspace Settings > Access Management > Tokens**.

2. Click**Create token** to generate a new token with the`Workspace Owner` role. Copy the token.

3. Return to your command line and use your token to authenticate:

$ segmentcli auth<ProfileName><AuthToken>

```

4. Copy your source's ID. You'll find the Source ID under**Settings> API Keys> Source ID** on your source's page.

After you've completed setup, you can deploy your apps to the Apple App Store and Google Play Store. You can then add new JavaScript plugin code to your mobile apps through the Segment website, and perform updates as often as needed.

You've now successfully attachedyourlive plugin(s) to your mobile source. The nexttime your users launch your app, their Segment SDK will download the latest live plugins, which will run everytime new events are generated.

> info""

> Because the CDN settings object takes a few minutes to rebuild, your live plugins might not be available immediately.

To access Live Plugins for your Swift and Kotlin sources:

1. In your Segment workspace, go to**Connections > Sources**.

2. Select your Swift or Kotlin source (or create a new one).

3. From the source's overview page, click the Live Plugin tab..

<imgalt="Access Live Plugins from the Source overview tab"src="https://github.com/user-attachments/assets/e228bddb-4cb8-4469-9ac6-8a2c322edcbc" />

Follow the stepsin this section to create your ownlive plugin.

Follow the steps in this section to createand deployyour ownLive Plugin.

In this example, you've created a`UserIdLivePlugin` by subclassing`LivePlugin` and implementing the`execute()` function. This function gets applied to every event.

After you define your customlive plugin, you need to add it to the Analytics instance. The Analytics object is globally accessible, and you can use the`add()` method to include yourlive plugin.

After you define your customLive Plugin, you need to add it to the Analytics instance. The Analytics object is globally accessible, and you can use the`add()` method to include yourLive Plugin.

When you adding a new instance, you specify the`LivePluginType` and the destination to which it applies, or use null to apply it to all destinations.

To control when your customLive Plugin runs duringtheeventlifecycle, you can use`LivePluginType` enums, which define different timing options for yourLive Plugin. Here are the available types:

constLivePluginType= {

}

With these enums, you can select the timing that best fits your customLive Plugin's target use case. These types align with categories used for Native Plugins.

The following live plugin examples address common use cases:

Liveplugins follow an interface thatlet you intercept Segment events and modify their data. This interface includes several functions that you can implement for custom behavior:

LivePlugins expose an interface thatlets you intercept Segment events and modify their data. This interface includes several functions that you can implement for custom behavior:

The`execute` callback function serves as the primary entry point forlive plugins to intercept and modify events. When you implement the`execute` function in your plugin, you can decide whether to keep the event by returning it or drop it by returning`null`.

The`execute` callback function serves as the primary entry point forLive Plugins to intercept and modify events. When you implement the`execute` function in your plugin, you can decide whether to keep the event by returning it or drop it by returning`null`.

This callback is versatile, as you can use it for various event types when the event type itself is not critical. Additionally,`execute` lets you invoke more specific callbacks based on the event type.

| Function| Description|

| ---------------| ---------------------------------------------------------------------------|

|`reset(): null`| Called when the Analytics instance is about to be reset. Nothing to return.|

|`reset(): null`| Called when the Analytics instance is about to be reset. Nothing to return.|