In-App-Nachrichten triggern

Erfahren Sie, wie Sie In-App-Nachrichten über das Braze SDK triggern.

Auslöser und Zustellung von Nachrichten

In-App-Nachrichten werden getriggert, wenn das SDK einen der folgenden angepassten Event-Typen protokolliert: Session Start, Push Click, Any Purchase, Specific Purchase und Custom Event (die letzten beiden mit umfangreichen Eigenschaftsfiltern).

Zu Beginn der Session eines Nutzers bzw. einer Nutzerin stellt Braze alle infrage kommenden In-App-Nachrichten auf dem Gerät zu und lädt gleichzeitig Assets vorab, um die Anzeigelatenz zu minimieren. Kommen für das auslösende Event mehrere In-App-Nachrichten infrage, wird nur die Nachricht mit der höchsten Priorität zugestellt. Weitere Informationen finden Sie unter Session-Lebenszyklus.

Hinweis

In-App-Nachrichten können nicht über die API oder durch API-Events getriggert werden—nur durch angepasste Events, die vom SDK protokolliert werden. Weitere Informationen zur Protokollierung finden Sie unter Angepasste Events protokollieren.

Arten von In-App-Nachrichten

Braze sendet beim Sitzungsstart die folgenden Arten von In-App-Nachrichten an die Geräte der Nutzer:innen: inapp und templated_iam. Als Dashboard-Nutzer:in sehen Sie die verschiedenen Arten nicht, aber Braze verarbeitet sie je nach Einrichtung und Inhalt unterschiedlich.

inapp (Standard)

Eine inapp-In-App-Nachricht (oder „Standard“-Nachricht) enthält bereits die erforderlichen Informationen, z. B. angepasste Attribute, die Braze bereits kennt. Wenn die In-App-Nachricht auf das Gerät heruntergeladen wird, sorgt das Trigger-Event in der Regel dafür, dass das SDK die inapp-In-App-Nachricht anzeigt, selbst wenn das Gerät offline oder im Flugmodus ist.

templated_iam (mit Template)

Eine templated_iam-In-App-Nachricht (oder „mit Template“) enthält die erforderlichen Informationen noch nicht. Braze muss eine weitere Anfrage stellen, um die Informationen abzurufen, bevor die Nachricht angezeigt werden kann.

In-App-Nachrichten werden als In-App-Nachrichten mit Template zugestellt, wenn Kampagnenberechtigung vor der Anzeige neu bewerten ausgewählt ist oder wenn einer der folgenden Liquid-Tags in der Nachricht vorkommt:

• canvas_entry_properties
• connected_content
• SMS-Variablen wie {sms.${*}}
• catalog_items
• catalog_selection_items
• event_properties

Das bedeutet, dass das Gerät beim Sitzungsstart nur den Trigger dieser In-App-Nachricht erhält und nicht die gesamte Nachricht. Wenn Nutzer:innen die In-App-Nachricht triggern, stellt ihr Gerät eine Netzwerkanfrage, um die eigentliche Nachricht abzurufen.

Hinweis

Die Nachricht wird nicht zugestellt, wenn das Gerät keinen Zugang zum Internet hat. Die Nachricht wird möglicherweise nicht zugestellt, wenn die Auflösung der Liquid-Logik zu lange dauert.

Schlüssel-Wert-Paare

Wenn Sie in Braze eine Campaign erstellen, können Sie Schlüssel-Wert-Paare als extras festlegen, die das In-App-Messaging-Objekt verwenden kann, um Daten an Ihre App zu senden.

• web
• android
• swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import * as braze from "@braze/web-sdk";

braze.subscribeToInAppMessage(function(inAppMessage) {
  // control group messages should always be "shown"
  // this will log an impression and not show a visible message
  if (inAppMessage instanceof braze.ControlMessage) {
    return braze.showInAppMessage(inAppMessage);
  }


  if (inAppMessage instanceof braze.InAppMessage) {
    const extras = inAppMessage.extras;
    if (extras) {
      for (const key in extras) {
        console.log("key: " + key + ", value: " + extras[key]);
      }
    }
  }
  braze.showInAppMessage(inAppMessage);
});

• java
• kotlin

1

Map<String, String> getExtras()

1

extras: Map<String, String>

Tipp

Weitere Informationen finden Sie in der KDoc.

Das folgende Beispiel verwendet angepasste Logik, um die Darstellung einer In-App-Nachricht anhand ihrer Schlüssel-Wert-Paare in extras festzulegen. Ein vollständiges Anpassungsbeispiel finden Sie in unserer Beispiel-App.

• swift
• objective-c

1
2
3
4

let customization = message.extras["custom-display"] as? String
if customization == "colorful-slideup" {
  // Perform your custom logic.
}

1
2
3
4
5
6

if ([message.extras[@"custom-display"] isKindOfClass:[NSString class]]) {
  NSString *customization = message.extras[@"custom-display"];
  if ([customization isEqualToString:@"colorful-slideup"]) {
    // Perform your custom logic.
  }
}

Automatische Trigger deaktivieren

In-App-Nachrichten werden standardmäßig automatisch getriggert. So deaktivieren Sie dieses Verhalten:

• web
• android
• swift
• flutter
• unity

Entfernen Sie den Aufruf von braze.automaticallyShowInAppMessages() aus Ihrem Lade-Snippet und erstellen Sie dann eine angepasste Logik, die festlegt, ob eine In-App-Nachricht angezeigt wird oder nicht.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

braze.subscribeToInAppMessage(function(inAppMessage) {
  // control group messages should always be "shown"
  // this will log an impression and not show a visible message

  if (inAppMessage.isControl) { // v4.5.0+, otherwise use  `inAppMessage instanceof braze.ControlMessage`
     return braze.showInAppMessage(inAppMessage);
  }

  // Display the in-app message. You could defer display here by pushing this message to code within your own application.
  // If you don't want to use the display capabilities in Braze, you could alternatively pass the in-app message to your own display code here.

  if ( should_show_the_message_according_to_your_custom_logic ) {
      braze.showInAppMessage(inAppMessage);
  } else {
      // do nothing
  }
});

Wichtig

Wenn Sie braze.showInAppMessage aufrufen, ohne braze.automaticallyShowInAppMessages() zu entfernen, werden Nachrichten möglicherweise doppelt angezeigt.

Für eine genauere Steuerung des Timings von Nachrichten, einschließlich des Zurückstellens und Wiederherstellens getriggerter Nachrichten, lesen Sie unser Tutorial: Getriggerte Nachrichten zurückstellen und wiederherstellen.

1. Implementieren Sie den IInAppMessageManagerListener, um einen angepassten Listener festzulegen.
2. Aktualisieren Sie Ihre Methode beforeInAppMessageDisplayed() so, dass sie InAppMessageOperation.DISCARD zurückgibt.

Für eine genauere Steuerung des Timings von Nachrichten, einschließlich späterer Anzeige und erneutem Einreihen in die Warteschlange, lesen Sie unsere Seite Nachrichten anpassen.

1. Implementieren Sie den Delegate BrazeInAppMessageUIDelegate in Ihrer App. Eine vollständige Anleitung finden Sie im Tutorial: In-App-Nachrichten-UI.
2. Aktualisieren Sie Ihre Delegate-Methode inAppMessage(_:displayChoiceForMessage:) so, dass sie .discard zurückgibt.

Für eine genauere Steuerung des Timings von Nachrichten, einschließlich des Zurückstellens und Wiederherstellens getriggerter Nachrichten, lesen Sie unser Tutorial: Getriggerte Nachrichten zurückstellen und wiederherstellen.

1. Überprüfen Sie, ob Sie den Initialisierer für die automatische Integration verwenden, der ab Version 2.2.0 standardmäßig aktiviert ist.
2. Legen Sie die Standard-Operation für In-App-Nachrichten auf DISCARD fest, indem Sie die folgende Zeile zu Ihrer Datei braze.xml hinzufügen.

   
   1
   
    <string name="com_braze_flutter_automatic_integration_iam_operation">DISCARD</string>
   
   

• android
• ios

Deaktivieren Sie für Android im Braze-Konfigurationseditor die Option Automatically Display In-App Messages. Alternativ können Sie com_braze_inapp_show_inapp_messages_automatically in der Datei braze.xml Ihres Unity-Projekts auf false setzen.

Die anfängliche Anzeige-Operation für In-App-Nachrichten können Sie in der Braze-Konfiguration über „In App Message Manager Initial Display Operation“ festlegen.

Legen Sie für iOS im Braze-Konfigurationseditor Listener für Spielobjekte fest und stellen Sie sicher, dass Braze Displays In-App Messages nicht ausgewählt ist.

Die anfängliche Anzeige-Operation für In-App-Nachrichten können Sie in der Braze-Konfiguration über „In App Message Manager Initial Display Operation“ festlegen.

Zwei In-App-Nachrichten in einer Sitzung verketten

Sie können eine In-App-Nachricht beim Sitzungsstart triggern und anschließend eine zweite In-App-Nachricht, nachdem in der ersten ein Button gedrückt wurde. Loggen Sie dazu ein angepasstes Event für den Button-Klick, das die zweite Nachricht triggert. Der Trigger für die zweite Nachricht muss bereits auf dem Gerät vorhanden sein (die Nutzer:innen müssen also bereits für die zweite Nachricht berechtigt sein) und auf Geräteseite auftreten (das Braze SDK erkennt keine Änderungen an angepassten Attributen, die auf den Braze-Servern erfolgen). Die standardmäßige Wartezeit von 30 Sekunden zwischen In-App-Nachricht-Triggern muss geändert werden, damit mehrere In-App-Nachrichten kurz hintereinander angezeigt werden können. Informationen zur plattformspezifischen Konfiguration finden Sie unter Standard-Rate-Limit überschreiben.

Überschreiben des Standard-Rate-Limits

Standardmäßig begrenzt das SDK getriggerte In-App-Nachrichten auf eine alle 30 Sekunden. Um dies zu überschreiben, fügen Sie Ihrer Konfigurationsdatei die folgende Eigenschaft hinzu, bevor die Braze-Instanz initialisiert wird. Dieser Wert wird als neues Rate-Limit in Sekunden verwendet.

Setzen Sie diesen Wert bei Produktions-Apps nicht unter 10 Sekunden, damit Nutzer:innen nicht mit unmittelbar aufeinanderfolgenden In-App-Nachrichten überhäuft werden. Für Tests und Abläufe in Beispiel-Apps sind 5 Sekunden eine gängige Einstellung.

Zu Testzwecken können Sie dieses Intervall auf 0 setzen. Ein Intervall von 0 Sekunden erzwingt jedoch nicht, dass mehrere In-App-Nachrichten gleichzeitig angezeigt werden. Ist bereits eine In-App-Nachricht sichtbar, wird eine weitere getriggerte Nachricht erst angezeigt, wenn die aktuelle Nachricht geschlossen wurde.

• web
• android
• swift

1
2

// Sets the minimum time interval between triggered in-app messages to 5 seconds instead of the default 30
braze.initialize('YOUR-API-KEY', { minimumIntervalBetweenTriggerActionsInSeconds: 5 })

1

<integer name="com_braze_trigger_action_minimum_time_interval_seconds">5</integer>

1
2
3
4
5
6
7
8

let configuration = Braze.Configuration(
  apiKey: "YOUR-APP-IDENTIFIER-API-KEY",
  endpoint: "YOUR-BRAZE-ENDPOINT"
)
// Sets the minimum trigger time interval to 5 seconds
configuration.triggerMinimumTimeInterval = 5
let braze = Braze(configuration: configuration)
AppDelegate.braze = braze

1
2
3
4
5
6
7

BRZConfiguration *configuration =
    [[BRZConfiguration alloc] initWithApiKey:@"<BRAZE_API_KEY>"
                                    endpoint:@"<BRAZE_ENDPOINT>"];
// Sets the minimum trigger time interval to 5 seconds
configuration.triggerMinimumTimeInterval = 5;
Braze *braze = [BrazePlugin initBraze:configuration];
AppDelegate.braze = braze;

Nachrichten manuell triggern

Standardmäßig werden In-App-Nachrichten automatisch getriggert, wenn das SDK ein angepasstes Event protokolliert. Zusätzlich können Sie Nachrichten mit den folgenden Methoden manuell triggern.

Verwendung eines serverseitigen Events

• web
• android
• swift

Derzeit unterstützt das Web Braze SDK das manuelle Triggern von Nachrichten über serverseitige Events nicht.

Um eine In-App-Nachricht über ein vom Server gesendetes Event zu triggern, senden Sie eine stille Push-Benachrichtigung an das Gerät. Damit kann ein angepasster Push-Callback ein SDK-basiertes Event protokollieren. Dieses Event triggert dann die für Nutzer:innen sichtbare In-App-Nachricht.

Schritt 1: Push-Callback für den Empfang des stillen Push erstellen

Registrieren Sie Ihren angepassten Push-Callback, um auf eine bestimmte stille Push-Benachrichtigung zu reagieren. Weitere Informationen finden Sie unter Push-Benachrichtigungen einrichten.

Für die Zustellung der In-App-Nachricht werden zwei Events protokolliert: eines vom Server und eines aus Ihrem angepassten Push-Callback heraus. Damit dasselbe Event nicht doppelt erfasst wird, sollte das Event aus Ihrem Push-Callback einer generischen Namenskonvention folgen, zum Beispiel „in-app message trigger event“, und nicht denselben Namen wie das vom Server gesendete Event tragen. Andernfalls können Segmentierung und Nutzerdaten durch doppelte Events für eine einzelne Nutzeraktion verfälscht werden.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11

Braze.getInstance(context).subscribeToPushNotificationEvents(event -> {
  final Bundle kvps = event.getNotificationPayload().getBrazeExtras();
  if (kvps.containsKey("IS_SERVER_EVENT")) {
    BrazeProperties eventProperties = new BrazeProperties();

    // The campaign name is a string extra that clients can include in the push
    String campaignName = kvps.getString("CAMPAIGN_NAME");
    eventProperties.addProperty("campaign_name", campaignName);
    Braze.getInstance(context).logCustomEvent("IAM Trigger", eventProperties);
  }
});

1
2
3
4
5
6
7
8
9
10
11

Braze.getInstance(applicationContext).subscribeToPushNotificationEvents { event ->
    val kvps = event.notificationPayload.brazeExtras
    if (kvps.containsKey("IS_SERVER_EVENT")) {
        val eventProperties = BrazeProperties()

        // The campaign name is a string extra that clients can include in the push
        val campaignName = kvps.getString("CAMPAIGN_NAME")
        eventProperties.addProperty("campaign_name", campaignName)
        Braze.getInstance(applicationContext).logCustomEvent("IAM Trigger", eventProperties)
    }
}

Schritt 2: Push-Campaign erstellen

Erstellen Sie eine stille Push-Campaign, die über das vom Server gesendete Event getriggert wird.

Die Push-Campaign muss Schlüssel-Wert-Paare als Extras enthalten, die angeben, dass diese Push-Campaign gesendet wird, um ein angepasstes SDK-Event zu protokollieren. Dieses Event wird verwendet, um die In-App-Nachricht zu triggern.

Der obige Beispielcode für den Push-Callback erkennt die Schlüssel-Wert-Paare und protokolliert das entsprechende angepasste SDK-Event.

Wenn Sie Event-Eigenschaften an Ihr „in-app message trigger“-Event anhängen möchten, übergeben Sie diese in den Schlüssel-Wert-Paaren der Push-Payload. In diesem Beispiel wurde der Campaign-Name der nachfolgenden In-App-Nachricht hinzugefügt. Ihr angepasster Push-Callback kann den Wert dann beim Protokollieren des angepassten Events als Parameter der Event-Eigenschaft übergeben.

Schritt 3: In-App-Nachrichten-Campaign erstellen

Erstellen Sie Ihre für Nutzer:innen sichtbare In-App-Nachrichten-Campaign im Braze-Dashboard. Diese Campaign sollte eine aktionsbasierte Zustellung haben und durch das angepasste Event getriggert werden, das aus Ihrem angepassten Push-Callback heraus protokolliert wird.

Im folgenden Beispiel wurde die konkrete In-App-Nachricht, die getriggert werden soll, über die Event-Eigenschaft konfiguriert, die mit dem ursprünglichen stillen Push gesendet wurde.

Wird ein vom Server gesendetes Event protokolliert, während sich die App nicht im Vordergrund befindet, wird das Event zwar erfasst, die In-App-Nachricht aber nicht angezeigt. Wenn Sie das Event verzögern möchten, bis sich die Anwendung im Vordergrund befindet, müssen Sie in Ihrem angepassten Push-Receiver eine Prüfung einbauen, die das Event verwirft oder verzögert, bis die App in den Vordergrund gewechselt ist.

Schritt 1: Stillen Push und Schlüssel-Wert-Paare verarbeiten

Implementieren Sie die folgende Funktion und rufen Sie sie innerhalb der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:): auf:

• swift
• objective-c

1
2
3
4
5
6

func handleExtras(userInfo: [AnyHashable : Any]) {
  print("A push was received")
  if userInfo != nil && (userInfo["IS_SERVER_EVENT"] as? String) != nil && (userInfo["CAMPAIGN_NAME"] as? String) != nil {
    AppDelegate.braze?.logCustomEvent("IAM Trigger", properties: ["campaign_name": userInfo["CAMPAIGN_NAME"]])
  }
}

1
2
3
4
5
6

- (void)handleExtrasFromPush:(NSDictionary *)userInfo {
  NSLog(@"A push was received.");
  if (userInfo !=nil && userInfo[@"IS_SERVER_EVENT"] !=nil && userInfo[@"CAMPAIGN_NAME"]!=nil) {
    [AppDelegate.braze logCustomEvent:@"IAM Trigger" properties:@{@"campaign_name": userInfo[@"CAMPAIGN_NAME"]}];
  }
};

Wenn der stille Push empfangen wird, wird ein vom SDK erfasstes Event „in-app message trigger“ im Nutzerprofil protokolliert.

Wichtig

Da eine Push-Nachricht verwendet wird, um ein vom SDK protokolliertes angepasstes Event zu erfassen, muss Braze für jede:n Nutzer:in ein Push-Token speichern, damit diese Lösung funktioniert. Bei iOS-Nutzer:innen speichert Braze ein Token erst ab dem Zeitpunkt, zu dem ihnen die Push-Abfrage des Betriebssystems angezeigt wurde. Vorher sind Nutzer:innen per Push nicht erreichbar, und die beschriebene Lösung ist nicht möglich.

Schritt 2: Stille Push-Campaign erstellen

Erstellen Sie eine stille Push-Campaign, die über das vom Server gesendete Event getriggert wird.

Die Push-Campaign muss Schlüssel-Wert-Paare als Extras enthalten, die angeben, dass diese Push-Campaign gesendet wird, um ein angepasstes SDK-Event zu protokollieren. Dieses Event wird verwendet, um die In-App-Nachricht zu triggern.

Der Code in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:) prüft auf den Schlüssel IS_SERVER_EVENT und protokolliert ein angepasstes SDK-Event, wenn dieser vorhanden ist.

Sie können den Event-Namen oder die Event-Eigenschaften ändern, indem Sie den gewünschten Wert in den Schlüssel-Wert-Paar-Extras der Push-Payload senden. Beim Protokollieren des angepassten Events können diese Extras als Parameter für den Event-Namen oder als Event-Eigenschaft verwendet werden.

Schritt 3: In-App-Nachrichten-Campaign erstellen

Erstellen Sie Ihre für Nutzer:innen sichtbare In-App-Nachrichten-Campaign im Braze-Dashboard. Diese Campaign sollte eine aktionsbasierte Zustellung haben und durch das angepasste Event getriggert werden, das in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:) protokolliert wird.

Im folgenden Beispiel wurde die konkrete In-App-Nachricht, die getriggert werden soll, über die Event-Eigenschaft konfiguriert, die mit dem ursprünglichen stillen Push gesendet wurde.

Hinweis

Beachten Sie, dass diese In-App-Nachrichten nur getriggert werden, wenn der stille Push empfangen wird, während sich die Anwendung im Vordergrund befindet.

Vordefinierte Nachricht anzeigen

Um eine vordefinierte In-App-Nachricht manuell anzuzeigen, verwenden Sie die folgende Methode:

• web
• android
• swift

1

BrazeInAppMessageManager.getInstance().addInAppMessage(inAppMessage);

1

BrazeInAppMessageManager.getInstance().addInAppMessage(inAppMessage)

1

AppDelegate.braze?.inAppMessagePresenter?.present(message: inAppMessage)

Nachricht in Realtime anzeigen

Sie können lokale In-App-Nachrichten auch in Realtime erstellen und anzeigen – mit denselben Anpassungsoptionen, die im Dashboard verfügbar sind. Gehen Sie dazu wie folgt vor:

• web
• android
• swift
• unity

1
2
3
4

  // Displays a slideup type in-app message.
  var message = new braze.SlideUpMessage("Welcome to Braze! This is an in-app message.");
  message.slideFrom = braze.InAppMessage.SlideFrom.TOP;
  braze.showInAppMessage(message);

• java
• kotlin

1
2
3

// Initializes a new slideup type in-app message and specifies its message.
InAppMessageSlideup inAppMessage = new InAppMessageSlideup();
inAppMessage.setMessage("Welcome to Braze! This is a slideup in-app message.");

1
2
3

// Initializes a new slideup type in-app message and specifies its message.
val inAppMessage = InAppMessageSlideup()
inAppMessage.message = "Welcome to Braze! This is a slideup in-app message."

Wichtig

Zeigen Sie keine In-App-Nachrichten an, während die Bildschirmtastatur eingeblendet ist, da das Rendering in diesem Fall nicht definiert ist.

Rufen Sie die Methode present(message:) manuell auf Ihrem inAppMessagePresenter auf. Zum Beispiel:

• swift
• objective-c

1
2
3
4

let customInAppMessage = Braze.InAppMessage.slideup(
  .init(message: "YOUR_CUSTOM_SLIDEUP_MESSAGE", slideFrom: .bottom, themes: .defaults)
)
AppDelegate.braze?.inAppMessagePresenter?.present(message: customInAppMessage)

1
2
3
4
5
6
7
8
9

BRZInAppMessageRaw *customInAppMessage = [[BRZInAppMessageRaw alloc] init];
customInAppMessage.type = BRZInAppMessageRawTypeSlideup;
customInAppMessage.message = @"YOUR_CUSTOM_SLIDEUP_MESSAGE";
customInAppMessage.slideFrom = BRZInAppMessageRawSlideFromBottom;
customInAppMessage.themes = @{
  @"light": BRZInAppMessageRawTheme.defaultLight,
  @"dark": BRZInAppMessageRawTheme.defaultDark
};
[AppDelegate.braze.inAppMessagePresenter presentMessage:customInAppMessage];

Hinweis

Wenn Sie Ihre eigene In-App-Nachricht erstellen, verzichten Sie auf jegliches Analytics-Tracking und müssen das Protokollieren von Klicks und Impressionen manuell über Ihren message.context vornehmen.

Um die nächste Nachricht im Stack anzuzeigen, verwenden Sie die Methode DisplayNextInAppMessage(). Nachrichten werden in diesem Stack gespeichert, wenn DISPLAY_LATER oder BrazeUnityInAppMessageDisplayActionType.IAM_DISPLAY_LATER als Anzeigeaktion für die In-App-Nachricht gewählt ist.

1

Appboy.AppboyBinding.DisplayNextInAppMessage();

Ursachen für Verzögerungen bei In-App-Nachrichten

Wenn Sie eine In-App-Nachricht-Campaign erst einige Sekunden nach dem Sitzungsstart erhalten, kann die Verzögerung folgende Ursachen haben:

• Eine Verzögerung beim Trigger der Campaign
• Anpassungen
• Das Trigger-Event wird später als erwartet erfasst (zum Beispiel bei einem templated_iam)

Exit-Intent-Nachrichten für Web

Exit-Intent-Nachrichten sind unaufdringliche In-App-Nachrichten, mit denen Sie Besucher:innen wichtige Informationen mitteilen, bevor sie Ihre Website verlassen.

Um Trigger für diese Nachrichtentypen im Web SDK einzurichten, implementieren Sie eine Exit-Intent-Bibliothek auf Ihrer Website (z. B. die Open-Source-Bibliothek von ouibounce). Verwenden Sie dann den folgenden Code, um 'exit intent' als angepasstes Event in Braze zu protokollieren. Ihre zukünftigen Campaigns für In-App-Nachrichten können diesen Nachrichtentyp dann als Trigger für angepasste Events verwenden.

1
2
3

  var _ouibounce = ouibounce(false, {
    callback: function() { braze.logCustomEvent('exit intent'); }
  });