Braze Currents

Understanding the impacts of your engagement strategy is critical in informing how you iterate and optimize communications with your users. To ensure that this valuable engagement data is tightly integrated with the rest of your operations, the Braze platform tracks a wide array of data from your integration for analysis, retargeting, and other use-cases elsewhere within your own systems. The Currents product provides a simple way to export data from Braze, in real-time, enabling a seamless data circuit.

Currents opens up a variety of powerful use-cases:

  • Pipe your Braze data into a data warehouse or one of our analytics partners for more detailed analysis.
  • Export your Braze messaging data in real-time to power responsive machine learning algorithms within your product.
  • Route your event data to a variety of other systems via Segment or mParticle.

Currents comes included with certain Braze packages. Please contact your Customer Success Manager or support@braze.com if you want access.

How It Works

Currents consists of integrations with several partners who can receive data (“Switches”). Whenever an event occurs within the system, Braze tracks it and forwards it to the Switches that you have enabled.

Currents allows you to export two categories of events:

  • Message Engagement Events: events associated with messages sent via Braze, such as Email Clicks, Mobile Push Opens, In-App Message Impressions, and much more.
  • Additional User Behavior Events: events associated with customer behavior, such as Sessions, Custom Events, and Purchases.

Each Switch has different events that can be exported. View the integration descriptions below to see the events available for each type.

Event Delivery Semantics

Timestamps exported by Currents are sent in the UTC timezone. If you were previously exporting events using the Raw Event Export, those events were exported with a time string of when the event occurred in your account’s local timezone. Please ensure that your ETL scripts are updated accordingly in order to reconcile data across export methods.

As a high-throughput system, Currents guarantees at-least-once delivery of events, meaning that duplicate events can occasionally be sent. If your use cases require exactly-once delivery semantics, you can use the unique identifier field that is sent with every event ("id") to deduplicate events.

Setting Up Currents

Currents is included with certain Braze packages. Please contact your Customer Success Manager if you have any questions or want to gain access.

To get started, visit the Currents page in the left sidebar, in the “Integrations” section of the Dashboard. You’ll be taken to the Currents integration management page.

Currents

Add a Switch by clicking the dropdown at the top right of the screen.

Adding an Integration

Each Switch requires a different set of configuration steps. To enable each integration, see the instructions below.

Currents Integrations

Amazon S3

Amazon S3 is a highly scalable storage system offered by Amazon Web Services. After transporting data into S3, you can use ETL processes (Extract, Transform, Load) to transfer your data to other locations.

The Amazon S3 Currents Switch will output data in the .avro format (learn more here). Currents will create a file for each event type using the format below:

currents/dataexport.<cluster-identifier>.S3.integration.<integration-id>/event_type=<event-type>/date=<date>/<schema-id>/<zone>/dataexport.<cluster-identifier>.S3.integration.<integration-id>+<partition>+<offset>.avro
  • <integration-id>: The unique ID for this Currents integration.
  • <event-type>: The type of the event in the file (see event list below).
  • <date>: The hour that events are processed. Formatted YYYY-MM-DD-HH.
  • <schema-id>: Used to version .avro schemas for backwards-compatibility. Integer
  • <zone>: For internal use by Braze. Single letter
  • <partition>: For internal use by Braze. Integer
  • <offset>: For internal use by Braze. Integer
  • <cluster-identifier>: For internal use by Braze. Will be a string such as “prod-01”, “prod-02”, “prod-03”, or “prod-04”. All files will have the same cluster identifier.

Data files will be added approximately every 5-15 minutes. Because file naming conventions may change in the future, Braze recommends searching all S3 keys that have a prefix of “currents”.

Avro Schema Changes

From time to time, Braze may make changes to the Avro schema when fields are added, changed, or removed. For our purposes here, there are two types of changes: breaking and non-breaking. In all cases, the <schema-id> will be advanced to indicate the schema was updated.

Non-breaking Changes

When a field is added to the Avro schema, we consider this a non-breaking change. Added fields will always be “optional” Avro fields (i.e. with a default value of null), so they will “match” older schemas according to the Avro schema resolution spec. These additions should have no effect on existing ETL processes as the field will simply be ignored until it is added to your ETL process. We recommend that your ETL setup is explicit about the fields it processes to avoid breaking the flow when new fields are added.

While we will strive to give advance warning in the case of all changes, we may include non-breaking changes to the schema at any time.

Breaking Changes

When a field is removed from or changed in the Avro schema, we consider this a breaking change. Breaking changes may require modifications to existing ETL processes as fields that were in use may no longer be recorded as expected.

All breaking changes to the schema will be communicated in advance of the change.

Getting Started

To get started, create a new S3 bucket for this integration. Then, create an IAM user in your AWS account that has the s3:PutObject, s3:GetBucketLocation and s3:ListObject permissions for the new S3 bucket. Gather the following information from the bucket and IAM user:

  • Access Key ID for user
  • Secret Access Key for user
  • Bucket Name

You can also add the following customizations, based on your needs:

  • Folder Path (defaults to currents)
  • AES-256 Encryption (defaults to OFF)

Add this information to the Amazon S3 Currents page on the dashboard, and press save.

S3

Integration Details

A list of the data events that can be exported to Amazon S3 is below.

You can export two types of events events to Amazon S3: “Message Engagement Events” consisting of the Braze events that are directly related to message sending, and “Customer Behavior Events” including other App or Website activity such as Sessions, Custom Events, and Purchases tracked through the platform. Please contact your Account Manager or support@braze.com if you need access to additional event entitlements.

Message Engagement Events

Push Notification Events

// Push Notification Send: users.messages.pushnotification.Send
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "app_id": (string) id for the app on which the user action occurred,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "device_id": (string) id of the device that we made a delivery attempt to,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
// Push Notification Open: users.messages.pushnotification.Open
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "app_id": (string) id for the app on which the user action occurred,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device that we made a delivery attempt to,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
// Push Notification Bounce: users.messages.pushnotification.Bounce
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "app_id": (string) id for the app on which the bounce occurred,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "device_id": (string) id of the device that we made a delivery attempt to,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}

Email Events

// Email Send: users.messages.email.Send
// Email Delivery: users.messages.email.Delivery
// Email Open: users.messages.email.Open
// Email Click: users.messages.email.Click
// Email Bounce: users.messages.email.Bounce
// Email Mark As Spam: users.messages.email.MarkAsSpam
// Email Unsubscribe: users.messages.email.Unsubscribe
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "email_address": (string) email address for this event,
  "url": (string) the url that was clicked (Email Click events only)
}

In-App Message Events

// In-App Message Impression: users.messages.inappmessage.Impression
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "card_id": (string) API ID of the card this in app message comes from,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}
// In-App Message Click: users.messages.inappmessage.Click
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "button_id": (string) index of the button clicked, if it was a button that was clicked,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "card_id": (string) API ID of the card this in app message comes from,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}

Webhook Events

// Webhook Send: users.messages.webhook.Send
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}

News Feed Events

// News Feed Card Impression: users.messages.newsfeed.Impression
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "card_id": (string) id of the card that was viewed,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}
// News Feed Card Click: users.messages.newsfeed.Click
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "card_id": (string) id of the card that was clicked,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}
// News Feed Impression: users.behaviors.app.NewsFeedImpression
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}

Uninstall Events

// Uninstall Event: users.behaviors.Uninstall
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "app_id": (string) id for the app on which the user action occurred
}

Conversion Events

// Campaign Conversion Event: users.campaigns.Conversion
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "campaign_id": (string) id of the campaign,
  "campaign_name": (string) name of the campaign,
  "conversion_behavior_index": (int) index of the conversion behavior,
  "conversion_behavior": (string) JSON-encoded string describing the conversion behavior,
  "message_variation_id": (string) id of the message variation,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
//
// Canvas Conversion Event: users.canvas.Conversion
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "canvas_id": (string) id of the canvas,
  "canvas_name": (string) name of the Canvas,
  "conversion_behavior_index": (int) index of the conversion behavior,
  "conversion_behavior": (string) JSON-encoded string describing the conversion behavior,
  "canvas_variation_id": (string) id of the Canvas variation the user is in,
  "canvas_step_id": (string) id of the last step the user was sent before the conversion
}

Canvas Entry Events

// Canvas Entry Event: users.canvas.Entry
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "canvas_id": (string) id of the Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in,
  "in_control_group": (boolean) whether the user was enrolled in the control group for a Canvas
}

Campaign Control Group Enrollment Events

// Campaign Control Group Enrollment: users.campaigns.EnrollInControl
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "campaign_id": (string) id of the campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
Customer Behavior Events

Custom Events

// Custom Event: users.behaviors.CustomEvent
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "name": (string) name of the custom event,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred,
  "properties": (string) JSON encoded string of the custom properties for this event
}

Purchase Events

// Purchase Event: users.behaviors.Purchase
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "product_id": (string) id of the product purchased,
  "price": (float) price of the purchase,
  "currency": (string) three letter alpha ISO 4217 currency code,
  "properties": (string) JSON encoded string of the custom properties for this event,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}

Session Events

// Session Start: users.behaviors.app.SessionStart
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "session_id": (string) id of the session,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the session occurred
}
// Session End: users.behaviors.app.SessionEnd
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "session_id": (string) id of the session,
  "duration": (float) seconds session lasted,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the session occurred
}

Location Events

// Location Event: users.behaviors.Location
{
  "id": (string) unique id of this event,
  "user_id": (string) braze user id of the user,
  "external_user_id": (string) External ID of the user,
  "time": (int) time of the event in seconds since the epoch,
  "longitude": (float) longitude of recorded location,
  "latitude": (float) latitude of recorded location,
  "altitude": (float) altitude of recorded location,
  "ll_accuracy": (float) latitude/longitude accuracy of recorded location,
  "alt_accuracy": (float) altitude accuracy of recorded location,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device,
  "device_id": (string) id of the device on which the event occurred
}
Transferring data to Redshift

Amazon Redshift is a popular data warehouse that runs on Amazon Web Services alongside Amazon S3. Braze data from Currents is structured to be easy to transfer to Redshift directly. Examples of how to transfer data from Amazon S3 to Redshift via an ETL process are available on Github here.

Amplitude

Amplitude is a product analytics and business intelligence platform. You can export the data events from your Braze integration to Amplitude in order to perform deep analysis of your product and marketing data.

To get started, find the following information from your Amplitude dashboard:

  • Amplitude API Key

Add this information to the Amplitude integration page on the dashboard, and press save.

Amplitude

Amplitude’s documentation is available here.

Integration Details

A list of the events that can be exported from Braze to Amplitude is below. All events sent to Amplitude will include the user’s external_user_id as the Amplitude User ID. At this time, Braze does not send event data for users who do not have their external_user_id set. Braze-specific event properties will be sent under the event_properties key in the data sent to Amplitude. The properties for each event type are listed below.

You can export two types of events events to Amplitude: “Message Engagement Events” consisting of the Braze events that are directly related to message sending, and “Customer Behavior Events” including other App or Website activity such as Sessions, Custom Events, and Purchases tracked through the platform. Please contact your Account Manager or support@braze.com if you need access to additional event entitlements.

Message Engagement Events

Push Notification Events

// Push Notification Send
{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.)
}
// Push Notification Open
{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}
// Push Notification Bounce
{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the bounce occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.)
}

Email Events

// Email Send
// Email Delivery
// Email Open
// Email Click
// Email Bounce
// Email Mark As Spam
// Email Unsubscribe
{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "email_address": (string) email address for this event,
  "url": (string) the URL that was clicked (Email Click events only)
}

In-App Message Events

// In-App Message Impression
{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}
// In-App Message Click
{
  "button_id": (string) index of the button clicked, if it was a button that was clicked,
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions),
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Webhook Events

{
  "campaign_id": (string) id of the campaign if from a campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation if from a campaign,
  "canvas_id": (string) id of the Canvas if from a Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in if from a Canvas,
  "canvas_step_id": (string) id of the step for this message if from a Canvas,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}

News Feed Events

// News Feed Card Impression
{
  "card_id": (string) id of the card that was viewed,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}
// News Feed Card Click
{
  "card_id": (string) id of the card that was clicked,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}
// News Feed Impression
{
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Uninstall Events

{
  "app_id": (string) id for the app on which the user action occurred
}

Conversion Events

// Campaign Conversion Event
{
  "campaign_id": (string) id of the campaign,
  "campaign_name": (string) name of the campaign,
  "conversion_behavior_index": (int) index of the conversion behavior,
  "conversion_behavior": (string) JSON-encoded string describing the conversion behavior,
  "message_variation_id": (string) id of the message variation,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
// Canvas Conversion Event
{
  "canvas_id": (string) id of the Canvas,
  "canvas_name": (string) name of the Canvas,
  "conversion_behavior_index": (int) index of the conversion behavior,
  "conversion_behavior": (string) JSON-encoded string describing the conversion behavior,
  "canvas_variation_id": (string) id of the Canvas variation the user is in,
  "canvas_step_id": (string) id of the last step the user was sent before the conversion
}

Canvas Entry Events

{
  "canvas_id": (string) id of the Canvas,
  "canvas_name": (string) name of the Canvas,
  "canvas_variation_id": (string) id of the Canvas variation the user is in,
  "in_control_group": (boolean) whether the user was enrolled in the control group for a Canvas
}

Campaign Enrollment Events

// Campaign Control Group Enrollment
{
  "campaign_id": (string) id of the campaign,
  "campaign_name": (string) name of the campaign,
  "message_variation_id": (string) id of the message variation,
  "send_id": (string) id of the message if specified for the campaign (See Send Identifier under REST API Parameter Definitions)
}
Customer Behavior Events

Custom Events

{
  // Custom Event Name
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Purchase Events

{
  "product_id": (string) id of product purchased (sent in the “productId” field of Amplitude HTTP API),
  "price": (float) price of product (sent in the “price” field of Amplitude HTTP API),
  "currency": (string) three letter alpha ISO 4217 currency code,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Session Events

// Session Start
{
  "session_id": (string) id of the session,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}
// Session End
{
  "session_id": (string) id of the session,
  "duration": (float) seconds session lasted,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Location Events

{
  "longitude": (float) longitude of recorded location,
  "latitude": (float) latitude of recorded location,
  "altitude": (float) altitude of recorded location,
  "ll_accuracy": (float) a percentage representing the OS determined accuracy of the recorded location,
  "alt_accuracy": (float) altitude accuracy of recorded location,
  "app_id": (string) id for the app on which the user action occurred,
  "platform": (string) platform of the device (iOS, Android, web, etc.),
  "os_version": (string) os version of device used for the action,
  "device_model": (string) hardware model of the device
}

Rate Limits

Currents connects to Amplitude’s HTTP API, which has a Rate Limit of 60 events/second per device. Above that threshold, Amplitude will throttle events that are logged through Currents. If a device in your integration is sending above this rate limit, you may experience a delay in when events from all devices will appear in Amplitude.

Devices should not report more than 60 events/second under normal circumstances, and this event pattern should only occur due to a misconfigured integration. To avoid this type of delay, ensure that your SDK integration is reporting events at a normal rate as specified in our SDK integration instructions.

Amplitude Data Import

Using Braze and Amplitude’s deep partnership, you can configure your integration to import Amplitude cohorts directly into Braze for retargeting, creating a full loop of data from one system to another. This allows you to perform deep analysis using Amplitude and seamlessly execute on your strategies using Braze.

You can manage the Amplitude Data Import process from the 3rd Party Integrations page. Note that any integration that you setup will count towards your account’s data point volume.

Amplitude cohort import

mParticle

mParticle is a customer data platform that collects and routes information from multiple sources to a variety of other locations in your marketing stack.

To get started, find the following information from your mParticle dashboard:

  • mParticle Server to Server Key
  • mParticle Server to Server Secret

Add this information to the mParticle integration page on the dashboard, and press save.

mParticle

All events sent to mParticle will include the user’s external_user_id as the customerid. At this time, Braze does not send event data for users who do not have their external_user_id set.

mParticle’s documentation is available here.

Integration Details

You can export the following data from Braze to mParticle:

Event Name Feed Type Description
Push Notification Send Platform-specific Feed A push notification was successfully sent to a User.
Push Notification Open Platform-specific Feed User opened a push notification.
Push Notification Bounce Platform-specific Feed Braze was not able to send a push notification to this User.
Email Sent Unbound Feed An email was successfully sent.
Email Delivered Unbound Feed An email was successfully delivered to a User’s mail server.
Email Opened Unbound Feed User opened an email.
Email Clicked Unbound Feed User clicked a link in an email. Email click tracking must be enabled.
Email Bounced Unbound Feed Braze attempted to send an email, but the User’s receiving mail server did not accept it.
Email Marked As Spam Unbound Feed User marked an email as spam.
Email Unsubscribed Unbound Feed User clicked the unsubscribe link in an email.
In-App Message Impression Platform-specific Feed User viewed an In-App Message.
In-App Message Clicked Platform-specific Feed User tapped or clicked a button in an In-App Message.
News Feed Viewed Platform-specific Feed User viewed the native Braze News Feed.
News Feed Card Viewed Platform-specific Feed User viewed a Card within the native Braze News Feed.
News Feed Card Clicked Platform-specific Feed User clicked on a Card within the native Braze News Feed.
Webhook Sent Unbound Feed A webhook message was sent on behalf of a User.
Application Uninstalled Platform-specific Feed User uninstalled the App.
Campaign Conversion Event Unbound Feed User performed the primary conversion event for a Campaign within its conversion window.
Campaign Enrollment in Control Group Unbound Feed User was enrolled in a Campaign control group.
Canvas Conversion Event Unbound Feed User performed the primary conversion event for a Canvas within its conversion window.
Canvas Entry Unbound Feed User was entered into a Canvas.

Segment

Segment is a customer data platform that collects and routes information from multiple sources to a variety of other locations in your marketing stack.

To get started, find the following information from your Segment dashboard:

  • Segment Write Key

Add this information to the Segment integration page on the dashboard, and press save.

Segment

All events sent to Segment will include the user’s external_user_id as the userId. At this time, Braze does not send event data for users who do not have their external_user_id set.

Segment’s documentation is available here.

Integration Details

You can export the following data from Braze to Segment:

Event Name Description
Push Notification Sent A push notification was successfully sent.
Push Notification Tapped User opened a push notification.
Push Notification Bounced Braze was not able to send a push notification to this User.
Email Sent An email was successfully sent.
Email Delivered An email was successfully delivered to a User’s mail server.
Email Opened User opened an email.
Email Link Clicked User clicked a link in an email. Email click tracking must be enabled.
Email Bounced Braze attempted to send an email, but the User’s receiving mail server did not accept it.
Email Marked As Spam User marked an email as spam.
Email Unsubscribed User clicked the unsubscribe link in an email.
In-App Message Viewed User viewed an In-App Message.
In-App Message Clicked User tapped or clicked a button in an In-App Message.
News Feed Viewed User viewed the native Braze News Feed.
News Feed Card Viewed User viewed a Card within the native Braze News Feed.
News Feed Card Clicked User clicked on a Card within the native Braze News Feed.
Application Uninstalled User uninstalled the App.

The following properties will be included with all Braze events sent to Segment:

Property Name Type Description
app_id String The API Identifier of the App on which a user received a message or performed an action, if applicable.
campaign_id String The API Identifier of the Campaign associated with the event, if applicable.
campaign_name String The name of the Campaign associated with the event, if applicable.
message_variation_id String The API Identifier of the Message Variation for the Campaign associated with the event, if applicable.
canvas_id String The API Identifier of the Canvas associated with the event, if applicable.
canvas_name String The name of the Canvas associated with the event, if applicable.
canvas_variation_id String The API Identifier of the Canvas Variation associated with the event, if applicable.
canvas_step_id String The API Identifier of the Canvas Step associated with the event, if applicable.
context.traits.email String For Email events, the email address that the email was sent to.
link_url String For Email Clicked events, the URL of the link that the user clicked on.
button_id String For In-App Message Clicked events, the index of the button the user clicked on.
card_id String For News Feed Card Viewed and News Feed Card Clicked events, the API Identifier of the News Feed Card.

mParticle Integration

Braze is dedicated to creating partner integrations that allow you to send data from multiple sources to your Dashboard. mParticle is an analytics data hub that allows you to track your users and route that data to a wide variety of user analytics providers, such as Braze. mParticle has a basic core integration which only allows access to our push notification and segmentation, as well as an embedded SDK option which ensures your ability to take advantage of in-app messages, the news-feed and feedback as well.

Note: When passing user attribute data, please be sure that you are only passing values for attributes that have changed since the last update. This will ensure that you do not unnecessarily consume data points towards your allotment.

Setting Up mParticle

Braze recommends using the embedded SDK flavor of the mParticle/Braze integration as push notifications alone don’t form a complete marketing strategy. You can enable the additional functionality by following their Braze specific documentation.

Enabling Push Notifications

Push Notifications via mParticle and Braze must be enabled through the integration steps included in this section of the mParticle documentation.

Enabling Location Tracking

Location Tracking via mParticle and Braze must be enabled through the integration steps included in this section of the mParticle documentation.

News Feed Customization & Integration

In addition to using the embedded SDK, you must also integrate the news-feed directly into your application as it functions as a rich message inbox for users that updates in real time based upon the segments they’re a member of. For directions on integrating the news-feed, see our iOS and Android documentation.

Segment Integration

Braze is dedicated to creating partner integrations that allow you to send data from multiple sources to your Dashboard. Segment is an analytics data hub that allows you to track your users and route that data to a wide variety of user analytics providers, such as Braze. We offer both a side-by-side SDK integration for your Android, iOS and web applications and a server-to-server integration for your backend services so that you can start building richer user profiles.

Side-by-Side SDK Integration

Braze’s side-by-side integration maps Segment’s SDK to ours, allowing access to deeper features and a more comprehensive usage of Braze than the server-to-server integration. These mappings of Segment’s SDK for Android, iOS and Analytics.js (Segment’s Javascript SDK) are open source and can be found on our GitHub page.

To complete the side-by-side integration, please refer to Segment’s detailed instructions for Android and iOS. For Braze’s Web SDK, Segment’s Analytics.js library dynamically pulls in and initializes our Web SDK when you add Braze as a destination on your Segment dashboard. However, to use Braze’s browser notification capabilities, please refer to Segment’s Web documentation.

Important: If you are given a custom endpoint for your Braze integration, be sure to add the custom endpoint to the “Custom API Endpoint” and your correct “Braze Datacenter” on your Braze destination settings found in Segment’s dashboard. For the side-by-side integration, the “App Group REST API Key” is not necessary.

Segment's Dashboard UI

For more details regarding Braze’s SDKs, please refer to our iOS, Android and Web documentation.

Server-to-Server Integration

The server-to-server integration forwards data from Segment to Braze’s REST API. This integration is only used in assciation with Segment’s server-side libraries, such as their Ruby or Go SDKs. Enable the integration by setting your App Group REST API Key and Braze’s Rest API endpoint for your corresponding data center in your destination settings on Segment’s dashboard.

Segment's Go Integration

Unlike the side-by-side integration, however, the server-to-server integration does not support any of Braze’s UI features, such as in-app messaging, News Feed, Feedback or push notifications.

Getting Started

Once the Segment library is integrated with your server, and Braze is added as a destination on your Segment dasboard, you can begin routing data.

Braze supports the identify, track, and group methods; however, our REST APIs require you to include a user ID when making these calls.

Identify

When you identify a user, we will record information for that user with userId as the External User ID. Segment’s special traits recognized as Braze’s standard user profile fields (in parentheses) are firstName (first_name), lastName (last_name), birthday (dob), avatar (image_url), address.city (home_city), address.country (country), and gender (gender). All other traits will be recorded as custom attributes.

Note: When passing user attribute data, please be sure that you are only passing values for attributes that have changed since the last update. This will ensure that you do not unnecessarily consume data points towards your allotment.

Track

When you track an event, we will record that event as a custom event using the name provided.

Completed Order

When you track an event with the name Completed Order using the format described in Segment’s ECommerce API, we will record the products you’ve listed as purchases.

Group

When you call group, we will record a custom attribute with the name ab_segment_group_<groupId>, where groupId is the group’s ID in the method’s parameters. For example, if the group’s ID is 1234, then the custom attribute name will be ab_segment_group_1234. The value of the custom attribute will be set to true.

Enabling Push Notifications

Currently, Braze’s server-to-server integration with Segment does not support methods for push tokens. In order to enable push notifications in Braze, you must import push tokens via the User Attribute Object of our User Data REST API.

How To Tell If You’re Receiving Data From Segment

Some automatically captured data is only available through the side-by-side integration. The following data is not available via the server-to-server integration:

  • Sessions
  • First Used App
  • Last Used App

Consequently, most of your app usage dashboard (lifetime sessions, MAU, DAU, Stickiness, Daily Sessions and Daily Sessions per MAU) will be blank even if Braze is receiving data from Segment.

You can view your data in the custom event dashboard, the revenue dashboard or by creating a segment. The custom event dashboard allows you to view custom event counts over time. Note that you will not be able to use formulas that include MAU and DAU statistics.

If you’re sending purchase data to Braze (see Completed Order), the revenue dashboard allows you to view data on revenue or purchases over specific periods of time or your app’s total revenue.

Creating a segment allows you to filter your users based on custom event data and custom attribute data. Note that filters related to automatically collected session data (such as “first used app” and “last used app”) will not work.

Attribution Integration

Attribution Overview

Braze supports integrations with several partners that track the users you acquire through paid advertising campaigns. These integrations make it possible to segment your users by acquistion channel and even by specific paid advertising campaigns. This is useful for determining the real value of users from a given acquisition channel by measuring their engagement throughout the customer lifecycle.

Available Partners

Partner iOS Support? Android Support? Windows Support?
adjust Yes Yes Yes
appsflyer Yes Yes Yes
Yes Yes No
branch Yes No No
kochava Yes Yes Yes
tune Yes Yes Yes

Don’t see your attribution service listed here? We might be able to add them! Contact your Customer Success manager and let us know who you’re working with.

Available Segment Filters

  • Attributed Source
  • Attributed Campaign
  • Attributed Adgroup
  • Attributed Ad

Facebook and Twitter Attribution Data

Please note that attribution data for Twitter and Facebook campaigns is not available through our partners. Facebook and Twitter do not permit their partners to share attribution data with third-parties and, therefore, our partners cannot send that data to Braze.

API Restrictions

Braze’s attribution integrations (except Adjust) are built on top of our REST API and subject to the same limits. In particular:

  • Access for enterprise customers is unlimited, but subject to contract terms.
  • Access for non-enterprise customers is limited to 100 requests (i.e. up to 100 attributed installs) per hour.
  • If you have questions about these limits, please contact your Customer Success manager.

Integration Instructions by Partner

Adjust

Step 1: Integration Requirements

  • This integration supports iOS and Android apps.
  • Your app will need Braze’s SDK and Adjust’s SDK installed.

Step 2: Modifying your app code

Braze’s integration with Adjust is an SDK-to-SDK integration, meaning that attribution data is collected by Adjust’s API and then sent to Braze through the Braze SDK. For this to work, you will need to modify your app’s code.

On iOS, you will need to modify your app code to register an attribution callback with Adjust that calls setAttributionData from Braze’s SDK. Example code snippet:

- (void)adjustAttributionChanged:(ADJAttribution *)attribution {
  ABKAttributionData *attributionData = [[ABKAttributionData alloc]
                                         initWithNetwork:attribution.network
                                         campaign:attribution.campaign
                                         adGroup:attribution.adgroup
                                         creative:attribution.creative];
  [[Appboy sharedInstance].user setAttributionData:attributionData];
}

On Android, you will need to modify your app code to set a listener for Adjust attribution changes that calls setAttributionData from Braze’s SDK. Example code snippet:

config.setOnAttributionChangedListener(new OnAttributionChangedListener() {
  @Override
  public void onAttributionChanged(AdjustAttribution attribution) {
    Appboy.getInstance(getApplicationContext()).getCurrentUser().setAttributionData(new AttributionData(
        attribution.network,
        attribution.campaign,
        attribution.adgroup,
        attribution.creative));
  }
});

Assuming you configure your integration as suggested above, Braze will map Adjust’s data to segment filters in the following way:

Adjust Attribution Parameter Braze Segment Filter
{network_name} Attributed Source
{campaign_name} Attributed Campaign
{adgroup_name} Attributed Adgroup
{creative_name} Attributed Ad

AppsFlyer

Step 1: Integration Requirements

  • This integration supports iOS and Android apps.
  • If you expect more than 100 attributed installs per hour, you will need a Braze Enterprise account. See API Restrictions for more information.
  • Your app will need Braze’s SDK and AppsFlyer’s SDK installed.
  • If you have an iOS app, you will need to enable IDFA collection in Braze’s SDK.
  • If you have an Android app, you will need to include the code snippet below, which passes a unique Braze device id to AppsFlyer. For most setups, this code should be included alongside all calls to AppsFlyerLib.setAppsFlyerKey, typically in an activity’s onCreate callback.
HashMap<String, Object> customData = new HashMap<String,Object>();
String deviceId =(Appboy.getInstance(MyActivity.this).getInstallTrackingId());
customData.put("customData", deviceId);
AppsFlyerLib.setAdditionalData(customData);

Step 2: Getting the Braze API Key

In Braze’s Dashboard, navigate to “3rd Party Integrations” > “Attribution” and find the API key and REST Endpoint in the AppsFlyer section. The API key and the REST Endpoint are used in the next step when setting up a postback in Appsflyer’s dashboard.

Step 3: Configure Braze in Appsflyer’s Dashboard

  • In Appsflyer’s dashboard, navigate to the “Integrated Partners” page.
  • On that page, search for Braze and click on Braze’s logo to open up a configuration window.
  • Under “Integration Parameters” select “enable”.
  • Copy the Braze API key (obtained in the prior step) into the “API_key” field.
  • Copy the Braze Rest Endpoint url (obtained in the prior step) into the “REST_endpoint” field.
  • Click “Save & Close”.

Additional information on these instructions is available in Appsflyer’s documentation.

Braze maps AppsFlyer’s data fields to segment filters in the following way

AppsFlyer Data Field Braze Segment Filter
media_source Attributed Source
campaign Attributed Campaign
af_adset Attributed Adgroup
af_ad Attributed Ad

Step 4: Confirming the Integration

Once Braze receives attribution data from AppsFlyer, the status connection indicator on “3rd Party Integrations” > “Attribution” will change to green and a timestamp of the last successful request will be included. Note that this will not happen until we receive data about an attributed install. Organic installs, which should be excluded by the AppsFlyer integration, are ignored by our API and are not counted when determining if a successful connection was established.

Singular

Step 1: Integration Requirements

  • This integration supports iOS and Android apps.
  • If you expect more than 100 attributed installs per hour, you will need a Braze Enterprise account. See API Restrictions for more information.
  • Your app will need Braze’s SDK and Singular’s SDK installed.
  • If you have an iOS app, you will need to enable IDFA collection in Braze’s SDK.
  • If you have an Android app, you will need to include the code snippet below, which passes a unique Braze user id to Singular. For most setups, 2 lines of code must be added in an app’s onCreate() method immediately after Singular’s init method or session start. Braze’s device_id must be available when the first “App Open” event is sent to Singular.
@Override
protected void onCreate(Bundle savedInstanceState)
{
    // Other code
    // Init Singular SDK
   Singular.init(context, config); // context is Application Context
   // Code For Braze
   String appboyDeviceId =(Appboy.getInstance(MyActivity.this).getInstallTrackingId());
   Singular.event("App Open", "appboyUserID", appboyDeviceId);
}

Step 2: Getting the Braze API Key

In Braze’s Dashboard, navigate to “3rd Party Integrations” > “Attribution” and find the API key and REST Endpoint in the Singular section. You will need to provide the API key and the REST Endpoint to your Singular Account Manager for the integration to be completed.

Step 3: Confirming the Integration

Once Braze receives attribution data from Singular, the status connection indicator on “3rd Party Integrations” > “Attribution” will change to green and a timestamp of the last successful request will be included. Note that this will not happen until we receive data about an attributed install. Organic installs, which should be excluded from the Singular postback, are ignored by our API and are not counted when determining if a successful connection was established.

Branch

Step 1: Integration Requirements

  • This integration supports iOS apps only.
  • If you expect more than 100 attributed installs per hour, you will need a Braze Enterprise account. See API Restrictions for more information.
  • Your app will need Braze’s SDK and Branch’s SDK installed.
  • You will need to enable IDFA collection in Braze’s SDK.

Step 2: Getting the Attribution ID

In Braze’s Dashboard, navigate to “3rd Party Integrations” > “Attribution” and find the API key and REST Endpoint in the Branch section. The API key and the REST Endpoint are used in the next step when setting up a webhook in Branch’s dashboard.

Step 3: Setting Up A Webhook from Branch

Follow these instructions to add a webhook in Branch’s dashboard. You will be prompted for the key and REST Endpoint that you found in Braze’s Dashboard in Step 2.

Step 4: Confirming the Integration

Once Braze receives attribution data from Branch, the status connection indicator on “3rd Party Integrations” > “Attribution” will change to green and a timestamp of the last successful request will be included. Note that this will not happen until we receive data about an attributed install. Organic installs are ignored by our API and are not counted when determining if a successful connection was established.

Kochava

Step 1: Integration Requirements

  • This integration supports iOS, Android, and Windows apps.
  • If you expect more than 100 attributed installs per hour, you will need a Braze Enterprise account. See API Restrictions for more information.
  • Your app will need Braze’s SDK and Kochava’s SDK installed.
  • You will need to enable IDFA collection in Braze’s SDK.

Step 2: Getting the Attribution ID

In Braze’s Dashboard, navigate to “3rd Party Integrations” > “Attribution” and find the API key and REST Endpoint in the Kochava section. The API key and the REST Endpoint are used in the next step when setting up a postback in Kochava’s dashboard.

Step 3: Setting Up A Postback from Kochava

Follow these instructions to add a postback in Kochava’s dashboard. You will be prompted for the key and REST Endpoint that you found in Braze’s Dashboard in Step 2. Select the “POST” request when creating the PostBack Call on Kochava’s dashboard.

Step 4: Confirming the Integration

Once Braze receives attribution data from Kochava, the status connection indicator on “3rd Party Integrations” > “Attribution” will change to green and a timestamp of the last successful request will be included. Note that this will not happen until we receive data about an attributed install. Organic installs are ignored by our API and are not counted when determining if a successful connection was established.

Note for Android and Windows Support: If you are planning to leverage the server side integration between Braze and Kochava, you’ll need to ensure that you utilize the ‘Identity Link’ method of the Kochava SDK to capture the ‘Braze ID’ for Android and Windows. Please ensure that you instrument this method to capture/pass the ‘Braze ID’ on SDK initialization to ensure it is available when Kochava is posting your data back to Braze via the server side integration.

Tune (MobileAppTracking)

Step 1: Integration Requirements

  • This integration supports iOS, Android, and Windows Universal apps.
  • If you expect more than 100 attributed installs per hour, you will need a Braze Enterprise account. See API Restrictions for more information.
  • Your app will need Braze’s SDK and Tune’s SDK installed.
  • If you have an iOS app, you will need to enable IDFA collection in Braze’s SDK.
  • If you have an Android app, you will need to include the code snippet below, which passes a unique Braze device id to Tune. For most setups, this code should be included alongside all calls to mobileAppTracker.setAndroidId or mobileAppTracker.setGoogleAdvertisingId, typically in an activity’s onCreate callback.
mobileAppTracker.setUserId(Appboy.getInstance(MyActivity.this).getInstallTrackingId());

Step 2: Getting the Postback URL

In Braze’s Dashboard, navigate to “3rd Party Integrations” > “Attribution” and find the Postback URL in the MobileAppTracking section. This url represents the api endpoint that an attribution partner will send data to. You will need this url in the next step when setting up a callback in Tune’s dashboard.

Step 3: Setting Up A Postback from Tune

Follow these instructions to set up a postback in Tune’s dashboard so that it sends attribution data to Braze. This should be configured to send to the Postback URL you copied from Braze’s Dashboard in Step 2. Also configure the Postback to only send data for non-organic installs.

Braze maps Tune’s Postback Macros to segment filters in the following way

Tune Postback Macro Braze Segment Filter
{advertiser_sub_publisher} Attributed Source
{advertiser_sub_campaign} Attributed Campaign
{advertiser_sub_adgroup} Attributed Adgroup
{advertiser_sub_ad} Attributed Ad

Step 4: Confirming the Integration

Once Braze receives attribution data from Tune, the status connection indicator on “3rd Party Integrations” > “Attribution” will change to green and a timestamp of the last successful request will be included. Note that this will not happen until we receive data about an attributed install. Organic installs, which should be excluded from the Tune postback, are ignored by our API and are not counted when determining if a successful connection was established.

Branch Integration

Braze is dedicated to creating partner integrations that streamline your users’ brand experiences. Our partnership with Branch unifies linking infrastructure across different devices, platforms and channels.

Install Attribution

Branch offers an install attribution feature to measure user acquisition. See our Attribution documentation for integration instructions.

Deep Linking

Follow Branch’s SDK Integration Guide to get up and running with your Branch and Braze integration. For additional use cases, see below.

To support sending iOS Universal Links as deep links from within Braze:

  1. Follow Branch’s documentation for setting up Universal Links.
  2. Add ABKURLDelegate to your Braze SDK integration to route Universal Links from within your app. See our Linking Customization documentation for implementation details.

Deep Linking in Email

To set up deep linking from emails sent through Braze, see Branch’s documentation.

Depending on your ESP, additional customization is required in order to support click-tracked Universal Links:

AWS S3 Integration

Follow the instructions on this page to get started with your AWS S3 integration. AWS S3 integration is required for advanced data export functionality. Note that these instructions do not apply to Braze Currents integrations to AWS S3. Please see the Currents Documentation for those details.

Obtaining AWS S3 Credentials

If you already have an S3 bucket, we still recommend creating a new bucket for Braze so you can limit permissions.

Step 1

To create a bucket for your app, open the Amazon S3 console and follow the instructions to Sign in or Create an Account with AWS.

Step 2

Once signed in, select ‘S3’ from the ‘Storage & Content Delivery’ Category.

S3 Creds

Step 3

Select ‘Create Bucket’ on the next screen and you’ll be prompted to create your bucket and select a region. Click here for information on Bucket Restrictions and Limitations, as well as naming conventions.

Create Bucket

Step 4

To retrieve your access ID and secret access key, you’ll need to create your first IAM User and Administrators Group. Follow these step-by-step instructions.

Step 5

Once a user has been created, please select ‘Show User Security Credentials’ so your Access Key ID and Secret Access Key will be revealed. Click the blue ‘Download Credentials’ button as you will need to input this into the Braze dashboard later on.

Secret Key

Step 6

Now, you’ll need to navigate to the Policies tab in the navigation bar and select ‘Get Started’ then ‘Create Policy’ which will allow you to add permissions for your user. Select ‘Create Your Own Policy’. This will give limited permissions so we only have the ability to access the bucket that you specify.

Policy

Below is the code you need to input when creating your own policy. You will have to specify a ‘Policy Name’ of your choice, and input the code below into the ‘Policy Document’ section. Be sure to replace ‘INSERTBUCKETNAME’ with your own bucket name.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": ["s3:ListBucket", "s3:GetBucketLocation"],
            "Resource": ["arn:aws:s3:::INSERTBUCKETNAME"]
        },
        {
            "Effect": "Allow",
            "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
            "Resource": ["arn:aws:s3:::INSERTBUCKETNAME*", "arn:aws:s3:::INSERTBUCKETNAME/", "arn:aws:s3:::INSERTBUCKETNAME"]
        }
    ]
}

Step 7

Once your policy has been created, you will need to select ‘Users’ and then click into your specifc user so you can attach this new policy. On the ‘Permissions’ tab, click ‘Attach Policy’.

Attach User

Search for the new policy that you created and click to attach.

You are now ready to link your AWS credentials to your Braze account.

Linking Braze to AWS S3

Step 1

Navigate to the ‘3rd Party Integrations’ page on the Braze Dashboard under the ‘APP SETTINGS’ section and click the ‘AWS Credentials’ tab.

AWS Creds

Step 2

On the AWS Credentials page, input your AWS Access ID, AWS Secret Access Key, and AWS S3 Bucket Name in the designated fields. When inputting your secret key, click ‘Test Credentials’ first to ensure your credentials work, then ‘Save’ once this is successful.

Note: You can always retrieve new credentials by navigating to your user and clicking ‘Create Access Key’ on the Security Credentials Tab within the AWS Console.

Integration Complete

AWS S3 should now be integrated into your Braze account. A notification will inform you if your credentials have been successfully validated.

Apteligent Integration

Braze is dedicated to creating partner integrations that provide data-driven approaches to improving your application’s user experience. The Apteligent and Braze partnership combines Braze’s multichannel engagement automation with Apteligent’s detailed crash reporting, allowing you to log critical data into your existing Braze solution. Together, Apteligent and Braze can help you segment, understand, and engage with your users who have experienced application crashes.

Note: This integration is currently only supported on iOS.

iOS Integration

To integrate Apteligent with Braze on iOS, do the following:

Step 1

Register an observer. Ensure that this is done before you initialize Apteligent.

[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(crashDidOccur:)
                                             name:@"CRCrashNotification"
                                           object:nil];

Step 2

The Apteligent SDK will fire a notification when the user loads the application after a crash occurs. The notification will contain the crash name, reason, and date of occurrence.

Upon receiving the notification, log a custom crash event and update user attributes with Apteligent’s crash reporting analytics:

- (void)crashDidOccur:(NSNotification*)notification {
  NSDictionary *crashInfo = notification.userInfo;
  [[Appboy sharedInstance] logCustomEvent:@"ApteligentCrashEvent" withProperties:crashInfo];
  [[Appboy sharedInstance].user setCustomAttributeWithKey:@"lastCrashName" andStringValue:crashInfo[@"crashName"]];
  [[Appboy sharedInstance].user setCustomAttributeWithKey:@"lastCrashReason" andStringValue:crashInfo[@"crashReason"]];
  [[Appboy sharedInstance].user setCustomAttributeWithKey:@"lastCrashDate" andDateValue:crashInfo[@"crashDate"]];
}

That’s it! Now you’ll be able to harness the power of Braze’s segmentation, analytics, and engagement using the crash information that Apteligent provides.

Implementation Example

See our sample implementation in the AppDelegate.m file of the Stopwatch sample application.

Quark App Studio Integration

The instructions on this page will help Quark App Studio apps get started on their Braze integration. You’ll find details on how to fill out the following form:

Form

Getting Set Up

Before you begin filling out the form, take the following steps:

  1. If you have not already registered, create a Braze account on braze.com.
  2. Follow the app group configuration documentation to set up your first app. During this step, you can set up your production and development (testing) apps. Completing this will give you information necessary for filling out the form.

App Group REST API Key

  1. In your Braze Dashboard, go to the menu bar and click on Developer Console, which is located under App Settings.
  2. You will see your REST API Key in the API Settings tab:

api_key_img

iOS Segment ID

  1. In your Braze Dashboard, make sure you’re in your Production app group.
  2. Navigate to the Segments page, which is located under Engagement in the lefhand menu bar.
  3. Check to see if there is a segment called “All Users (Your App’s Name - iOS).” If so, click on that segment and skip to step 5. If not, go to step 4.
  4. Create a segment called All iOS Users that contains all of your app’s iOS users. When creating the segment, go to the Apps Used section and ensure that only your iOS app is checked. In addition, make sure there are no filters are applied. (The segment statistics for your app will differ from what you see in our sample screenshot).
  5. Staying on the page for the segment of all iOS users, scroll down to find your Segment API Identifier.

Android Segment ID

  1. In your Braze Dashboard, make sure you’re in your Production app group.
  2. Navigate to the Segments page, which is located under Engagement in the lefhand menu bar.
  3. Check to see if there is a segment called “All Users (Your App’s Name - Android).” If so, click on that segment and skip to step 5. If not, go to the next step.
  4. Create a segment called All Android Users that contains all of your app’s Android users. When creating the segment, go to the Apps Used section and ensure that only your Android app is checked. In addition, make sure there are no filters are applied. (The segment statistics for your app will differ from what you see in this sample screenshot).
  5. Staying on the page for the segment of all Android users, scroll down to find your Segment API Identifier.

All Devices Segment ID

  1. In your Braze Dashboard, make sure you’re in your Production app group.
  2. Navigate to the Segments page, which is located under Engagement in the lefhand menu bar.
  3. Create a segment called All Users that contains all iOS and Android users. In the Apps Used section, check “Include users from all apps,” which will select both your Android and iOs app. Do not apply any filters. (The segment statistics for your app will differ from what you see in this sample screenshot).
  4. Staying on the page for the All Users segment, scroll down to find your Segment API Identifier.

GCM Sender ID

Your GCM Sender ID is your Google Project Number. Here are instructions on how to access it in the Google Developers Console.

Production Details

iOS API Key

  1. In your Braze Dashboard, make sure you are in your Production App Group.
  2. Go to the menu bar and click on Manage App Group, which is located under App Settings.
  3. In the App Settings tab, select your iOS production app. Make sure to click on the correct app.
  4. You’ll see your app’s iOS API key:

Production_iOS

Android API Key

  1. In your Braze Dashboard, make sure you are in your Production App Group.
  2. Go to the menu bar and click on Manage App Group, which is located under App Settings.
  3. In the App Settings tab, select your Android production app. Make sure to click on the correct app.
  4. You’ll see your app’s Android API key:

Production_Android

Development Details

iOS API Key

The steps below are similar to those for accessing your Production iOS API Key, except for you carry them out within your Development app group.

  1. In your Braze Dashboard, make sure you are in your Development App Group.
  2. Go to the menu bar and click on Manage App Group, which is located under App Settings.
  3. In the App Settings tab, select your iOS development app. Make sure to click on the correct app.
  4. You’ll see your app’s iOS API key listed.

Android API Key

The steps below are similar to those for accessing your Production Android API Key, except for you carry them out within your Development app group.

  1. In your Braze Dashboard, make sure you are in your Development App Group.
  2. Go to the menu bar and click on Manage App Group, which is located under App Settings.
  3. In the App Settings tab, select your Android development app. Make sure to click on the correct app.
  4. You’ll see your app’s Android API key listed.

Zapier Integration

Zapier is an automation tool that links software services together, similar to IFTTT (if this then that) for enterprise software. Utilizing Webhooks and API Triggered Campaigns, Braze can integrate with Zapier

Step 1: Add Wordpress as a Trigger and select New Post after you connect your account:

zapier1

Step 2: When Post Status is Published:

zapier2

Step 3: Add an Action “Webhook”:

zapier3

Step 4: Choose Post as the Type:

zapier4

Step 5: Setup Braze Post:

URL : https://rest.iad-01.braze.com/campaigns/trigger/send

Payload Type : JSON

Data : trigger_properties__name, api_key, campaign_id

zapier5

Note: The above is an example for customers on the US-01 instance. If you are not on this instance please refer to our API documentation to see which endpoint to make requests to.

Step 6: Create Braze Campaign:

zapier6

You can also use trigger_properties with Liquid to filter what or if the message is sent.

Third Party Liability

Braze or third parties may refer to third party products or functionality within the Braze online Documentation. Any use by a customer of such third party services or functionality, and any exchange of data between a customer and such third party, is solely between that customer and that third party. Braze does not warrant any third party services or functionality and shall have no liability in connection with a customer’s use thereof.

Foursquare Integration

To unlock even more powerful location-based campaign targeting, Braze provides a seamless product integration with location intelligence company Foursquare. You can use Foursquare’s Pilgrim SDK on iOS and Android to provide real-time event triggering based upon your users’ location in the physical world, allowing you to harness Foursquare’s powerful geotargeting capabilities and take action with Braze.

This partnership integration opens up a variety of powerful use-cases to help you personalize your users’ experiences:

  • Send customers a notification when they arrive at or leave a particular location based upon Foursquare contextual data, such as a concert venue or Home.
  • Trigger coupons or promotions for high-value customers when they arrive at a location.
  • Gather key demographic or behavioral data over time for richer retargeting.

Integration Details

To enable this integration, first integrate the Braze and Foursquare Pilgrim SDKs on Android and iOS. To integrate the Pilgrim SDK you simply add a few lines of code to your AppDelegate on iOS or MainActivity class on Android. You’ll then instantly began receiving visit events on the device or to a webhook - even when your app isn’t running.

In order to properly map the Braze and Foursquare SDKs, you will need to set the same user ID in both systems, using the changeUser method in the Braze SDK and the setUserId method of PilgrimUserInfo in the Pilgrim SDK.

Next, find your App Group and App IDs on the Developer Console section of the Braze Dashboard.

Braze Developer Console

Enter your Braze REST API Key and (optionally) App IDs in the Foursquare Pilgrim Console:

Pilgrim Developer Console

Once you have configured the Pilgrim Console, the Pilgrim SDK will automatically track location events and forward them to Braze, allowing you to retarget and segment your customers. See the Foursquare developer site for more details.

Note that the Pilgrim SDK requires that you enable location services.

Triggering Messages based upon Location events

You can set up a Campaign or Canvas in the Braze Dashboard that will action off of location events generated by the Pilgrim SDK. This integration route is ideal for real-time messaging right as users enter a venue of interest, or delayed follow-on communication after they’ve left it (e.g. a thank you note or reminder).

For example, you can setup an Action-Based Campaign within Braze that will send messages when a user arrives at home. Create a Campaign (or a Canvas) in Braze, and set it to send using Action-Based Delivery. For your trigger, use a Custom Event of arrival with an event property filter for locationType as shown below:

Pilgrim Developer Console

Retargeting users based upon their last known location

You can use the Pilgrim SDK to set a last_location Custom Attribute on your Braze users’ User Profiles. You can then use the “matches regex” comparison to retarget users who went to a particular location in the real world: for example, segmenting all users who were recently at a pizza place.

Pilgrim Developer Console

You can also segment users in Braze who visited a particular type of venue, based on Foursquare’s primaryCategoryId in a particular window of time. To leverage this data point for your retargeting use cases, please log primaryCategoryId as an event property during your audience segmentation process. To identify the users and properties used by the Foursquare API and Pilgrim SDK, please refer to the Foursquare developer site.

Radar Integration

Radar is a location platform for mobile apps. You can use Radar to add location context and tracking to your iOS and Android apps in <10 lines of code, allowing you to easily identify or retarget users and augment your marketing with rich location data.

The Radar platform has three products: Geofences, Insights, and Places.

  • Geofences: Radar geofencing supports many powerful features, including cross-platform support for unlimited geofences, polygon geofences, stop detection, and accuracy down to 30 meters. Create geofences to receive the entered_geofence and exited_geofence events.
  • Insights: Radar can learn a user’s approximate home and work locations and tell you when a user is at home, at work, or traveling. Turn on Insights on the Radar dashboard to receive the entered_home, exited_home, entered_office, exited_office, started_traveling, and stopped_traveling events.
  • Places: Radar can tell you when a user visits a place, even if you haven’t set up a geofence for that location. Places have category and chain information. Radar is integrated with Facebook Places, the same place database that powers Facebook and Instagram, with over 140M places worldwide. Turn on Places to receive the entered_place and exited_place events.

Whenever Radar events are generated, Radar will send custom events and user attributes to Braze. You can use events and user attributes to build location-based segments or trigger location-based campaigns.

Integration Details

In order to properly map data between the Braze and Radar SDKs, you will need to set the same user ID in both systems, using the changeUser method in the Braze SDK and the setUserId method in the Radar SDK.

To enable the integration, on the Braze Developer Console page, copy your group identifier. Then, on the Braze Manage App Group page, copy your iOS API keys and Android API keys.

Finally, on the Radar Integrations page under Braze (Note that Braze was previously named Appboy, and some partner documentation may reflect the prior naming):

  • Set “Enabled” to “Yes”
  • Paste in your group identifier and API keys. Note that you can set separate API keys for the Test and Live environments.

Whenever Radar events are generated, Radar will send custom events and user attributes to Braze. Events from iOS devices will be sent using your iOS API keys, and events and user attributes from Android devices will be sent using your Android API keys.

Use Cases

You can use custom events and user attributes to build location-based segments or trigger location-based campaigns.

For example, to build a segment of users who are currently traveling:

Radar Segment

Or, to trigger a campaign when a user enters a Starbucks with high confidence:

Radar Campaign

Telesign SMS

Telesign is a cloud communications platform helping the world’s leading websites and mobile applications across SMS messaging, voice messaging, mobile app verification and phone intelligence.

Using Telesign Example and Walkthrough

For this example, we’ll configure the Braze webhook channel to send SMS and MMS to your users, via Telesign’s SMS API.

To use Telesign’s SMS web service to send a request, you’ll need to use the following Webhook URL when composing a webhook in Braze: https://rest-api.telesign.com/v1/messaging

Step 1: Set Up Your Request Body

The Telesign API expects the request body to be URL-encoded, so you must change the request type in the Braze Webhook composer to Raw Text. The required parameters for the body of the request are Phone Number (phone_number), Message (message), and Message Type (message_type). You’ll need to have valid phone numbers on each user profile in your target audience. Telesign defines a valid phone number as the end user’s phone number with country code included.

telesign_step1.png

The image below depicts an example of what your request might look like if you are sending an SMS to each user’s phone number, with the body “Hello from Braze!”.

Step 2: Compose Request Headers and HTTP Method

Telesign requires two request headers, the request Content-Type and an HTTP Basic Authentication header.

headerchart.png

Add these to your webhook by clicking the gear icon on the right side of the Webhook composer, then clicking Add New Pair twice.

When you add them to your webhook, be sure to replace TELESIGN_CUSTOMER_ID and TELESIGN_API_KEY in the Header Values with values from your Telesign dashboard. Lastly, Telesign’s API endpoint expects an HTTP POST request, so choose that option in the dropdown for HTTP Method.

telesign_step2.png

Step 3: Preview Your Request

Use the Webhook composer to preview the request for a random user, or for a user with particular credentials, to ensure that the request is rendering properly.

telesign_step3.png

Make adjustments as needed, and be sure to save your template! Happy messaging!