Branch’s Android SDK enables extensive functionality for your app, making it important to thoroughly test the integration before release. To streamline this process, Branch has revamped its Integration Validator tool to automate testing. 

New functionality includes: 

• Automated configuration testing, including Branch keys, package name, and domains
• A popup modal displaying test results
• Detailed failure explanations with links to relevant documentation
• Single-click log exporting
• A deep linking validator with auto-generated links for edge case testing
• Testing how a Branch link behaves when clicked under different app states, such as when the app is in the background (warm start), in the foreground, or handling deep linking from a foreground click.

This post walks you through how to use the new testing and validation features to ensure your Branch integration is set up correctly.

How to validate your Branch SDK integration

Before using Branch SDK features, verify your setup with the following steps:

1. Add the following line of code to the bottom of the Main Activity’s onStart() function in your app: IntegrationValidator.validate(MainActivity.this);

2. Run your app on a device or emulator. The Branch Integration Validator modal will appear, showing:

• SDK Version: Confirm you are using the latest version. Check the Branch Android SDK Version History. 
• Validation tests: Each line item represents an integration check, along with a check icon if the test passed or an “x” if it failed. Let’s review what each test means. 
• Branch Instance: Verifies that the Branch singleton object is successfully initialized. 
• Branch Keys: Checks that you have added the Branch keys into your app.
• Package Name: Validates that the package name on your Branch Dashboard matches the package name of your app. 
• URI Scheme: Ensures that the URI scheme you added to the Android Manifest matches the URI scheme entered in your Branch Dashboard. This is important because Branch links will fall back to using URI schemes to open the app if App Links fail. 
• App Links: Ensures that Branch links were properly configured to work with Android App Links during setup.
• Custom Domain: Checks that the custom domain in your app matches the one in your Branch Dashboard when applicable.
• Default Domains: Checks that the app.link and test-app.link domains from your Branch Dashboard have been added to the AndroidManifest and that the values match.
• Alternate Domains: Checks that the -alternate.app.link and -alternate.test-app.link domains from your Branch Dashboard have been added to the AndroidManifest and that the values match.

If a test fails, you will also see a blue “Details” button.

Click this button to see the identified issue. Use the “More info” link to go directly to the relevant part of the documentation with instructions for fixing it.

3. Use the “Export Logs” button to copy or share logs. This is especially helpful if you need to contact support@branch.io for assistance. 
After validating your Branch SDK integration, the next step is to test the deep linking functionality.

How to validate your Branch deep linking logic

1. Open the Integration Validator modal and click “Test Deep Linking” on the bottom right.

2. Choose your routing key. You will see three options:

• $canonical_url: A Branch parameter used when a full web URL is required for deep linking, such as: https://monster-site.github.io/shop/item-detail-1.html?id=1.
• $deeplink_path: A Branch parameter used when the app expects a relative path for deep linking, such as: /shop/item-detail-1.
• Other (custom): Select this option if you don’t use $canonical_url or $deeplink_path, for example, if you route using another defined parameter.

3. After selecting the option that matches the key your app uses for deep link routing, click “Next.” You’ll see one of the following screens, depending on your choice:

On this screen, enter the corresponding value for the key you selected in the previous step. If you chose “Other (custom),” specify the key and value used for routing.

4. Click the “Generate Links for Testing” button at the bottom of the modal.

The modal is now divided into two sections: “Links for testing” and “Additional use cases to test.”

Each link has a row with three buttons: 

• Info: Gives you more information about how the link is set up and why it’s important to use for testing. 
• Share: Allows you to share the test deep link with yourself or a teammate via Slack or Messages. 
• Debug: Provides additional information in the event that the link doesn’t behave as expected. 

5. Similar to the rows with links, there are rows for additional use cases to test, each with info and debug buttons. The middle button, labeled “Test” instead of “Share,” lets you directly test the use case. For example, clicking the “Test” button for the warm start use case will background the app and trigger a link click to verify that the warm start functionality for Branch links is properly implemented.

If your app has deep link routing set up, you should be routed to the correct screen. You can also check the logcat in Android Studio to verify that the app correctly fetched the deep link data on warm start.

Using Branch’s Integration Validator ensures you spot and fix issues quickly. Before releasing your app, take two minutes to validate your configurations and test deep linking.

Want to learn more?

Check out the following resources: 

• How To Validate Your Branch Mobile SDK Integration
• How To Validate Your Branch Web SDK Integration

For troubleshooting assistance, reach out to your account team. To get started, request a demo today!

The post How To Use Branch’s New Integration Validator Functionality on Android appeared first on Branch.

Branch offers several powerful integrations with mParticle, including the mParticle Data Integration and mParticle Branch Kit. With the Data Integration, you can forward events tracked via the Branch software development kit (SDK) to mParticle, allowing you to view them alongside your existing analytics data. You can also import events tracked via the mParticle SDK into Branch. The mParticle Branch Kit simplifies the process further by enabling Branch SDK functionality and automatically sending events to both mParticle and Branch Dashboards. 

While these integrations enhance your data, some automatically forwarded events, like content events or user lifecycle events, may not align with your key analytics needs or key performance indicators (KPIs). Plus, they can have cost implications under Branch’s volume credits model, so it is important to manage what data gets sent to Branch. 

Filtering events imported from mParticle into Branch

When you set up a Data Integration to import mParticle events into Branch, all commerce, content, user lifecycle, and custom events you track will flow into Branch. To avoid duplicate data, Branch will warn you if you try to import events already being tracked. However, you may want to further specify which events are sent from mParticle to Branch. 

Using forwarding rules in the mParticle Dashboard

1. Navigate to the ‘Connections’ section of your mParticle Dashboard and select your configured Branch output destination. 

2. After selecting the output, click the ‘Forwarding’ tab to create a rule. 

You can create two types of rules:

• ‘Only Forward’ events that meet specified criteria.
• ‘Do Not Forward’ events that meet specified criteria.

In this example, we’ll leave the ‘Attribute Type’ set to ‘Event Attribute.’ The other option, ‘User Attribute,’ is more relevant when configuring rules around the user info present on the event. 

Next, specify the ‘Attribute Name’ (e.g., event_type or event_name) and the ‘Attribute Value.’ 

For instance, to prevent commerce events, like ‘Add to Cart’ and ‘Purchase,’ from being sent to Branch, set the ‘Attribute Name’ to event_type and the ‘Attribute Value’ to commerce. 

To only send purchase events to Branch, for example, set the rule to ‘Only Forward,’ with the ‘Attribute Name’ as event_name and the ‘Attribute Value’ as purchase. 

By setting up these simple forwarding rules, you’ll have more granular control over the data imported from mParticle into Branch, avoid duplicate data issues, and prevent overages in volume credit usage.

Want to learn more about Branch’s integrations with mParticle?

Check out the following help documentation: 

• Importing mParticle events into Branch
• Exporting Branch events to mParticle
• Branch SDK integration via mParticle Kit (Android)
• Branch SDK integration via mParticle Kit (iOS)

For troubleshooting assistance with data export setup, reach out to your account team. To get started, request a demo today!

The post How To Customize Event Forwarding From mParticle to Branch appeared first on Branch.

But which API should you use for each purpose? 

Who should use Branch’s data export APIs?

An introduction to Branch’s suite of data export products

With all of these different options, it is important to understand which API is the right tool for the job.

Custom Export API

The Custom Export API allows you to export device-level data and gives you the ability to select exactly which fields you want. You can also filter the data to only display events that are meaningful to your analysis. This makes this API useful for exporting data from the last seven days. There is also a corresponding UI on the Branch Dashboard, eliminating the need for query writing by hand. There is also a Pre-Configured Exports option which provides pre-built export configurations pertaining to the most common use cases. Since this data is log-level, personal identifiable information (PII) fields will be hashed after seven days.

Scheduled Log Exports API

The Scheduled Log Exports API allows you to set up a recurring export of select device-level data. You can specify the cadence to be hourly or daily, depending on how often you want the data. Furthermore, you can get the data automatically sent directly from Branch’s servers to your cloud data service, like an AWS S3 bucket or GCP. 

Pro tip: When first getting a feel for querying Branch data, we recommend using the Custom Export API. Once you have a query you like and want to run recurrently, you can use the Scheduled Log Exports API to easily set up a subscription. 

Data Integrations

Data Integrations allow you to leverage our existing integrations with a myriad of data and analytics partners like Adobe Analytics, Google Analytics, Segment, Amplitude, Braze, and many more. By enabling these integrations on the Dashboard and/or adding a few snippets of code to your app, you can have Branch events automatically forwarded to your chosen analytics platform. And, if you want to import events from a third-party source into Branch, you can leverage our integrations with customer data platforms (CDPs) like Segment and mParticle. 

Webhooks

Webhooks are useful if you need data from Branch in real time. For example, maybe you want to trigger an event on your server as soon as it is processed by Branch. Note that Webhooks do require some custom setup in the Branch Dashboard with freemarker syntax. 

Query API

The Query API is used to export select campaign-level data and can export data as far back as two years. If you want to gain insight into cost data from self-attributing networks, you can do so using this API. It is also worth noting that this API exports data in real time. This means you get instant results after running a query. It’s also crucial to understand that utilizing this API for third-party access, like agencies, relinquishes control over the data they may retrieve. 

Aggregate API

The Aggregate API allows limited-access users, like agencies, to programmatically export aggregate data filtered at a user-access level. This API can be very useful if you want to provide third parties, such as agencies and ad partners, with your Facebook campaign performance insights, since the deprecation of Facebook’s Advanced Mobile Measurement (AMM) program prevents log-level data exportation.

Note: An earlier version of the Aggregate API was known as the Cohort API. There is also a simplified version available through the Branch Dashboard. But to unlock the true power of this API, you will want to make queries programmatically.

Cross-Events Export API

The Cross-Events Export API is the latest addition to Branch’s suite of data export APIs. This API allows you to export aggregate data without any limit to the number of dimensions, from multiple data sources, and returns an unlimited number of rows. This can be done with only one query to multiple datasets, eliminating the need for manual and time-consuming work, while also maintaining data integrity across sources. It also takes into account user access permission levels, so agencies and other limited-access users can securely access only the data they need.

Daily Export API

Some customers may be familiar with Branch’s Daily Export API. This is an older API with less flexibility than the options discussed above — the Custom Export API is a much more sophisticated alternative — but we mention it here for completeness. To export data from a given day, you will need to wait until the following day at 7:00 pm UTC. The Branch Dashboard also allows you to perform a daily export without any coding. One caveat to consider is that all fields for the event will be exported. This means when analyzing data, you may export columns that aren’t relevant to your reports.

Finally, it is worth noting that when you export Branch data, you can also export Unified Analytics that were previously only available on the Branch dashboard. Unified Analytics are campaign data from all attribution methods, SKAdNetwork (SKAN), IDFA, IDFV, Apple Search Ads, and Android are merged in a single view after removing duplicate SKAN data. This now allows you to leverage the value of your holistic Branch data across sources.

Choosing the right API for the job

To choose the right export API, ask yourself the following questions:

• Do you need aggregate or log-level data?
• Does the data go to a dedicated analytics provider or an internal data warehouse?
• Do you need to give third parties, like agencies, a secure way to export your data?
• Do you want the data to be exported on a recurring basis?
• How often do you need the data?
• How far back in time are you looking to export?
• How many rows of data do you want to export?

This flowchart will help you determine which Branch data export solution is the best fit for your organization’s needs. 

First, determine whether you need log-level or aggregate data. Log-level data includes all metadata and user-level data for each event. You can think of this like a spreadsheet of raw event data. Aggregate data is summarized to show the events and the number of times each event occurred. This includes breakdowns across a subset of available dimensions. This like a spreadsheet of raw data that has been processed into a pivot table.

Aggregate data

Take into account whether you need to provide agencies or other third parties with a means to export your data while ensuring they only access data aligned with their user permissions. If so, assess whether you need to retrieve substantial data volumes from multiple sources. If so, you’ll want to use the Cross-Events Export API. Else, opt for the Aggregate API. If you want to export the data in real time or fetch data exactly as it is displayed in your Branch Dashboard, choose the Query API.

Log-level data

When aiming to export log-level data, there are additional factors to ponder. Consider whether you have a dedicated analytics provider or an in-house data warehouse.

If you have an analytics provider that’s partnered with Branch, then you can set up a data integration on the Branch Dashboard. Simply enter a few credentials and potentially include a few lines of code in your app. Note that integration requirements may vary slightly depending on the partner.

If Branch does not have an integration with your analytics provider, or you are sending the data to an internal system, the next step is to consider the frequency of data delivery required:

• If real-time data is your priority (e.g., triggering events on the server side), Webhooks are the ideal solution for you.
• For one-time data exports, utilize the Custom Export API.
• If you need exports on a recurring basis, Branch’s Scheduled Log Exports API is the right choice.
  

Want to learn more about exporting data from Branch?

Explore our free e-learning courses on Branch University, featuring dedicated modules on exporting data from Branch: 

• Data Feeds Technical Overview
• Data Feeds and APIs
• Scheduled Log Exports API

The post Which Branch Data Export Solution Should I Use? appeared first on Branch.

Scheduled Log Exports combines data customization and flexibility, allowing you to experience total data freedom. Now, you can receive updates on campaign performance and monitor data trends in one central location, as frequently as every hour. Send data to clients, partners, and team members, even if they don’t have access to the Branch Dashboard, and choose the specific data you want to see in your reports. Getting the precise data you need to optimize your mobile app campaigns has never been easier. 

Scheduled Log Exports levels up your campaign data

Scheduled Log Exports enhances data customization and flexibility by enabling you to:

1. Get your data sooner. With Scheduled Log Exports, choose the cadence at which your data is exported. With the option to deliver your data either hourly or daily, you’ll always have the most up-to-date information for making informed campaign decisions. 
2. Select your own data columns. Tailor your data export precisely to your needs by selecting which data columns to include. Say goodbye to unnecessary columns that clutter your view and focus only on what matters most to you.
3. Filter your data. Now, you have the freedom to export specific types of data, like attributed installs or Facebook-attributed purchases, ensuring you receive the insights that are most relevant to your needs.
4. Export your data directly to your cloud data solution. No need to manually request exports. Instead, your data goes directly to your S3 bucket or into Google Cloud Provider (GCP) where you can access it at any time. 
5. Set up recurring exports to agency and ad network partners. Enable scheduled exports to agencies while retaining control over data privacy by selectively hiding certain information from partners. This grants you enhanced oversight and protection of your data assets.
6. Set up recurring emails with custom reports. Share agency-attributed installs directly with your agency and ad network postback records with your ad network, streamlining communication and enhancing collaboration.

With more personalized reporting, you can access critical data quickly without the need to make manual requests. And with data delivered directly to you, you can confidently make informed decisions to optimize your mobile growth campaigns.

Scheduled Log Exports is available to customers using Data Feeds. To get started, reach out to your Branch account team. For more information, read our quick-start guide and API reference docs. 

The post Enhance Your Campaign Data With Scheduled Log Exports appeared first on Branch.

Here are four ways to boost your game’s rankings with Branch. 

Take users directly into your game from search results

One of the biggest decisions in mobile SEO is choosing whether an organic search result link will take users into the app or to a mobile website. If you choose to deep link a user into app content, you lose the attribution data that indicates where the user came from. On the other hand, directing the user to the mobile web will preserve valuable attribution data but sacrifice the convenience of deep linking the user to where they really want to go: your game. It boils down to a choice between UX and attribution insights. 

Branch’s unique SEO App Attribution solution solves this common problem with deep linking functionality that maintains attribution insights. You no longer need to choose between a great UX for players who have your mobile game installed and key analytical data that helps you make better marketing decisions. 

While this approach removes UX frustration for users who already have your game installed on their device, it still leaves the question of where to direct new users. 

Acquire new users with SEO App Attribution + Journeys Banners

To maximize your mobile game’s growth potential, you need a strategy for how and where to direct new users who discover your content through search engine results pages (SERPs). This is where smart banners come in. 

By combining Branch’s SEO App Attribution with Journeys web-to-app smart banners, you can create a seamless pathway to your app. When a user without the mobile game installed clicks on a SERP link, they are taken to the mobile website. Once they land on the mobile web, they see a Branch Journeys banner prompt to download your game in the app store. To increase web-to-app conversions, Journeys smart banners allow you to customize the banners with graphics from your mobile game properties and tailor their look, feel, and behavior using CSS or HTML. This winning combination ensures that you maximize your user acquisition efforts while providing the best possible player experience. 

In addition to thinking about SEO in a mobile web context, mobile game companies need a strategy in place to improve web SEO from mobile game content clicks. 

Attribute content clicks to web URLs for SEO

In a typical scenario, clicks on mobile app deep links don’t improve your content’s SEO. This means that even if you drive a myriad of users into your app and deliver an excellent user experience, those clicks do nothing to improve your rankings. A major downside. 

However, Branch lets you add a web URL to the content in the deep link, ensuring every click counts toward your SEO efforts. 

When you create a Branch link in your Branch Dashboard, or via SDK or API, one of the most important fields to use is $canonical_url. This field stores the web URL where you want to attribute content clicks for SEO purposes. 

For example, in the Branch Monster Game app, users may be able to post content to social media via a share button. Typically, clicking this shared link (e.g., https://branchster.app.link/play) will open the app and deep link the player to the relevant content in the game app. If the $canonical_url is set to the web equivalent for this content (e.g., https://monster-site.github.io/index.html), then whenever a user clicks https://branchster.app.link/play, the SEO score for https://monster-site.github.io/index.html will increase. You can assign the $canonical_url when creating the link in the Branch Dashboard, edit the link data if the Branch link is already created, or add the query parameter to the end of a link, like this: https://branchster.app.link/play?$canonical_url=https://monster-site.github.io/index.html. 

While attributing clicks to your website will boost its SEO ranking, you also need to ensure the site itself is optimized using Accelerated Mobile Pages (AMP). 

Improve conversion rates using AMP

Google’s AMP framework is a great tool to make your website load faster on mobile devices and boost your SEO ranking. If your website already uses accelerated mobile pages and you want to utilize Branch’s Web SDK, we have an AMP-specific version of our Web SDK. Aside from typical Branch Web SDK functionality like deep linking, attribution, and event tracking, it also allows you to show AMP-friendly Branch Journeys banners. This is important because AMP pages are designed to make it difficult for users to navigate to any location other than back to Google Search, which makes it nearly impossible to convert users who are accessing content through your mobile web pages. 

Branch’s AMP-compatible Journeys convert mobile web traffic from Google Search results to your app and take advantage of extra traffic from AMP pages. To create an AMP-compatible Journey, select the “AMP web” checkbox during the Journeys creation flow in the Branch Dashboard. 

Recap and next steps

Here are four tips to optimize your game’s Google Search ranking:

• Use Branch’s SEO App Attribution to take users directly into your mobile game without missing out on attribution insights.
• Combine SEO App Attribution with Branch Journeys banners to nudge users to download your mobile game.
• Leverage the $canonical_url when creating Branch links so that content clicks are attributed to the web links.
• Use Branch’s AMP-compatible Web SDK and Journeys to ensure fast load times and higher SEO ranking.

Want to learn more about using Branch in your mobile game apps? Learn how you can boost mobile game user acquisition and reengagement using Branch. 

To get started, request a demo with our team.

The post Boost Your Mobile Game’s Visibility and Mobile SEO With Branch appeared first on Branch.

This blog post highlights our Unity SDK’s key features, as well as some pro tips for integrating it into your project. 

Why use the Branch Unity SDK?

The Branch Unity SDK provides a number of benefits for your app, namely a better and more engaging user experience for players. By generating Branch links, you can route users directly to in-app content from any platform or channel. It also enables features like share sheets, letting users share links and other content from your app. Plus, Branch’s Unity SDK enables you to set an identity on events that can be used for cross-platform and device deduplication. Furthermore, you’ll be able to track events in the Branch Dashboard and other third-party analytics platforms. 

Screenshot of the Branch Dashboard showing app clicks and opens by operating system.

Without Branch’s Unity SDK—or if you use another game engine aside from Unity to build your mobile game—you would need to create a wrapper for Branch’s native Android and iOS SDKs in order to tap into this functionality or leverage a third-party solution.

How does it work?

The first step to using Branch’s Unity SDK is downloading the latest version and importing it into your project. Inside the imported Branch folder, you’ll find the Branch Prefab, which you can drag and drop into the first scene of your Unity project. It is important that it is placed in the first scene that opens when the app starts up so that the Branch SDK initializes and provides the data needed for deep linking functionality when the app is opened from a Branch link click. 

If you select the Branch Prefab object in the hierarchy, you’ll notice a Branch script attached in the inspector. Here you can enter information to link to your Branch Dashboard. The required fields are Branch key and App Links. Your Branch key is in the Account Settings section of the Branch Dashboard. For the App Links, navigate to the Configuration section. Finally, click “Apply Changes” to automatically update the native AndroidManifest.xml and Info.plist files, respectively. Note that if you have existing settings already setup in these files, it is possible to add these fields manually by following these Android and iOS steps. 

When you import the Branch SDK, you’ll get access to two folders: one is the Branch folder inside of the Assets folder, which has the C# scripts and Branch Prefab to add the Branch functionality to your app. The other is the Branch folder inside of the Plugins folder. Inside that are Android and iOS folders, which house the native code that the C# code utilizes to provide access to the native Branch functionality. 

To get the maximum benefit from the Branch Unity SDK in your mobile game or app, it is important to understand the various C# scripts that make up the functionality of this powerful cross-platform SDK and use them to your advantage when building new features. The Branch script is the Branch singleton object, which has the public methods you will be calling throughout your project when you want to tap into Branch functionality. To see which version of the Branch SDK you are using, look at the sdkVersion variable at the top of this file. 

Inside of the BranchEnums.cs script, you’ll find the enums that Branch defines, including currency type, all 25 standard events from our Event Ontology, and product categories. 

Two concepts that are very important but will be new to you if you haven’t worked with Branch SDKs before are Branch Universal Object (BUO) and Branch Link Properties. 

Branch Universal Object stores any content in your app that you want to track as metadata for an event—such as a product that can be purchased. This makes things like event tracking and content sharing easier and even helps boost your website’s SEO ranking when a user engages with your app content. 

Branch Link Properties are the fields that you have access to when a Branch link is clicked, such as the path to the deep link content, the last-attributed-touch data, and other metadata fields associated with that link. In the BranchLinkProperties.cs file, you’ll see items like tags, feature, alias, stage, and match duration. The control params are where the rest of the deep linking and custom data will be stored, which you can access when the Branch SDK initializes to deep link the user. You can also access these at any time during the session by calling Branch.getLatestReferringBranchLinkProperties() to retrieve the latest referring parameters from the Branch link click. For more information on reading deep link data and routing the user to in-app content, be sure to check out these step-by-step details in the Branch help docs. 

Avoiding conflicts with other plugins

If you already use several third-party SDKs in your Unity project, chances are that those SDKs may have their own custom activity and application classes that can cause conflicts with other SDKs like Branch. To avoid any conflicts, follow these steps: 

1. First, create a native Android file that extends the Activity class. Inside the onStart() function, it is important to call the BranchUnityWrapper’s initSession() function so that the Branch SDK gets initialized at the native layer. You can also add the initialization code for the other third-party plugins here as well. Override the onNewIntent() function, and make sure the super class’ version of the function is called in there.

2. Next, create a custom application class that extends the native Android Application class. Inside the onCreate() function, register the version of the Branch plugin, disable instant deep linking to have more control over the users’ deep linking experience, and initialize the Branch singleton. After, you can add any code required by other third-party plugins in your app.

Next steps

Find step-by-step setup instructions for integrating Branch’s Unity SDK into your mobile game in our help documentation. To learn more how you can boost mobile game user acquisition and reengagement using Branch, check out this post: Level Up Your Mobile Game With Branch. 

To get started, request a demo with our team.

The post Power Your Mobile Game Using Branch’s Unity SDK appeared first on Branch.

Step 1: Check the Integration Status tab

For a high-level look at how close the integration is to completion, check the Integration Status tab in your Branch Dashboard. When you log in to the Branch Dashboard, you’ll find the Integration Status tab on the left sidebar underneath the Configure section: 

On this page, scroll down to the Web SDK section, and you will see a percentage score that indicates your overall integration progress. 

While the Integration Status tab is a good first indicator of your progress, it does not necessarily indicate that everything is set up properly. Once all items on the page show 100% completion status, or if you are unsure how to complete a specific item, investigate further using dev tools. 

Step 2: Utilize dev tools to confirm the network calls

Nearly every major browser has a set of dev tools that you can utilize to examine the network calls made by a webpage. Since Branch’s Web SDK sends requests to the Branch server, you’ll want to ensure that the correct requests are made at the appropriate time. You’ll also be able to confirm if the responses sent from the Branch server to the website contain the expected data. For our example, we will use the Google Chrome Dev Tools. You can acess these by opening a Chrome browser, clicking the ellipsis icon on the upper right (three dots), and going to More Tools > Developer Tools.  

Next, open the website that has the Branch SDK integrated. Then, open the Network tab of the Chrome Dev Tools. 

At this point, the expected behavior of the Branch Web SDK is to make four network calls. We’ll take a detailed look at each of these in a moment, but here is a high-level overview of what each does:

• The first request, labeled branch-latest.min.js, indicates the presence of the Branch SDK on that webpage. 
• The second request, delineated in the screenshot below, starts with _r?sdk=web and indicates that the Web SDK has been initialized. 
• The third and fourth requests are both pageview events (we’ll discuss the difference between the two in a moment).
  

Ensure that all four of these requests have a status code of 200, meaning that they were successful. If any of them have an status code in the 400s, it means there is an issue from the code on your webpage. A status code in the 500s indicates a server error. Select each of the network calls, then click the Headers tab to see the Status Code for a given network call. 

If you see a call with branch-latest.min.js but not one starting with _r?sdk=web, it means that you have added the Branch SDK to the webpage but it isn’t getting initialized. Some common reasons this can happen are:

• You are injecting the SDK through a tag manager but not through a Custom HTML tag.
• Your website is set up as a Single Page Application. (In this case, you’ll need to manually track a pageview event through the Branch SDK each time the content on the page is updated.)

Pageview events are a critical piece of the Branch Web SDK’s functionality. If set up correctly, you should see two of them. Clicking pageview will show the details of the network call. If there are request or response bodies associated with the network call, you will be able to click on the tabs labeled Payload or Response to view them. The response for the first pageview should have metadata associated with it:

The second pageview event will have a much smaller response, letting you know if the Web SDK initialization succeeded or failed. 

Once you’ve confirmed that the four network calls are coming through correctly, you are ready to proceed to step three. 

Step 3: View web events in Branch Liveview

Now that you’ve confirmed the Web SDK is successfully integrated and getting initialized on the website, the next step is to check that any tracked web events are firing properly. Any customer using Branch’s Web SDK can perform the following checks on events tracked automatically by the Web SDK: web session start and pageview. A simple way to verify this is to use Branch’s Liveview tool. 

On the left sidebar of the Branch Dashboard, you will find Liveview under the Tools section. 

In this section of the Dashboard, you can filter by type of event, like pageview, then view events in real time (with up to a 2-minute delay) when you perform them on the webpage. You’ll also be able to see other metadata fields on the event, such as any custom data attached to the Branch Web SDK or custom attributes you programmatically added. 

Customers utilizing Branch’s Journeys product can perform the same validation for the Branch CTA view event that is automatically triggered whenever a Branch Journeys banner is displayed on a webpage. Additionally, if you track any web events through Branch, you can change the filter to content event, commerce event, custom event, or user lifecycle events, and perform the same checks. 

Don’t forget to click the Update Session button anytime you update the filter to apply the change. 

Once you’ve verified that the data is correctly flowing into Branch, you are ready to move onto the next step. 

Step 4: Launch an end-to-end Journey test on a test environment

Analyzing events and data is great but there is no replacement for actually launching a Journeys banner on a test environment and validating the behavior on your device. This will allow you to see exactly what the user will experience when viewing and interacting with a Journeys banner on your website. 

Validate & Test is the final step on the Journeys creation flow and looks at both the required and recommended steps in the Validation section. The required steps include having a valid audience to display the Journey to and integrating the Web SDK on the page where you intend to display the Journey. 

On the right hand side is a preview of the Journey along with an input field where you can enter a URL and create a test link. By using this link on your mobile device, you can see how the Journey will look for the end user. 

It is important to note that test links do not take filtering criteria into account, so you’ll still need to launch the Journey on your test environment and verify that any users that meet the filtering criteria see the Journey, and vice versa. 

Keep in mind, the experience when a user clicks a Journey is powered by a Branch link “under the hood.” So, if your QA team is testing across devices, or you want to automate testing by creating unit tests, you can retrieve the Branch link behind any Journeys banner by utilizing the browser dev tools. In the Network Tab, filter all requests by “branch” and inspect the “https://api2.branch.io/v1/pageview” request. Under Network Response, search for “app.link” to find a reference to the actual link that was embedded behind the button. You can then copy this link and append “?debug=1” to inspect its data.

By following these steps, you can thoroughly test your Branch integration and ensure a great user experience for every user who clicks on a Branch link, no matter what the scenario.

Have questions? Reach out to your account team. 

Want to learn more about getting started with Branch? Request a demo!

The post How To Validate Your Branch Web SDK Integration appeared first on Branch.

Step 1: Check the Integration Status tab

The Integration Status tab in your Branch Dashboard is the first place you’ll want to look for the overall status of a Branch integration. When you log in to the Branch Dashboard, you’ll find the Integration Status tab on the left sidebar underneath the Configure section:

Here, you’ll find a high-level overview of your Branch integration progress. The top of the page shows a Setup Progress score, which is the overall indication of your progress. If you are at 100%, you can skip to step two. Otherwise, keep reading to track down the remaining steps. 

This Setup Progress score breaks down into four subsections: Android SDK, iOS SDK, Web SDK, and Link Configuration. Each of these subcategories has a status, completion percentage, as well as a list of completed and remaining steps. 

Incomplete steps are marked with a grayed-out check, while completed steps have a green check. You’ll want to ensure that each of the steps in all four subsections has a green check to reflect 100% completion. 

While the Integration Status tab is a good first indicator of your progress, it is not the most comprehensive. Once all items on the page show 100% completion, or if you are unsure what else you need to do to complete a specific item, use Branch’s Integration Validator tool to get a more detailed look. 

Step 2: Utilize Branch’s Integration Validator

The Branch SDK has an automated testing tool that you can use to check the status of the integration and get detailed information about any misconfigurations or incomplete steps. To utilize the Integration Validator, simply add a line of code to your project, then run the app on an emulator or device. The line of code that you add will depend on which tech stack you are using for your project:

• Android: IntegrationValidator.validate(this) in Kotlin or IntegrationValidator.validate(MainActivity.this); in Java. More information here. 
• iOS: Branch.getInstance().validateSDKIntegration() in Swift or [[Branch getInstance] validateSDKIntegration]; in Objective-C. More information here. 
• Flutter: FlutterBranchSdk.validateSDKIntegration(); More information here. 
• For other cross-platform tech stacks, like React Native, use the Native Android & iOS steps at the native level of the project. 

The Integration Validator will check to ensure that the Branch keys, package name, URI schemes, Android App Links, Universal Links, and link domain settings from the Dashboard match those in the build. If there is a mismatch, it will likely cause unexpected behavior or a broken SDK experience, and you will be able to see what is wrong and how to fix it in the tool’s output. On iOS, the Integration Validator provides feedback in the form of a popup and XCode logs. 

On Android, this information is output to the logcat in Android Studio.  

If all of the checks pass, you have successfully completed the integration on the Branch Dashboard as well as at the code level. 

If something is still amiss, check the responses coming back from the Branch server to ensure that the server is sending the app the expected information. 

Step 3: Enable logging to check the responses from Branch

To see the requests sent to and from the Branch server, each of Branch’s SDKs features code that enables network logs to be output to the console. The line of code you add will depend on which tech stack you are using for your project:

• Android: Branch.enableLogging() in Kotlin or Branch.enableLogging(); in Java.
• iOS: Branch.getInstance().enableLogging() in Swift or [[Branch getInstance] enableLogging]; in Objective-C.
• React Native: RNBranchModule.enableLogging();
• For other cross-platform tech stacks, like Flutter, use the Native Android & iOS steps at the native level of the project. 

Once you add the code, you’ll see the endpoint, request, and response for each in-app event. 

Once everything checks out, the next place to continue investigating anomalous behavior is the link debugger. 

Step 4: Analyze expected behavior with Link Debugger

Whereas the previous steps ensured proper configuration for your app, the next step is to check the configuration of the link you are using to test. Sometimes, the link itself can be the culprit if it does not have the proper configurations and link data added when it’s created. To check, use Branch’s Link Debugger. 

First, ensure that you are signed into your Branch Dashboard and in the proper environment (live or test) for the link you want to check. Copy the Branch link and then add ?debug=1 on the end. For example, if my Branch link is https://branchster.app.link/3vqEJflHrGb, it would become https://branchster.app.link/3vqEJflHrGb?debug=1. Pasting the Branch link and suffix into the browser will open up the Link Debugger view:

One of the most helpful features on this screen is Link Routing Debugger, which allows you to view the expected behavior for each operating system and click location. To start, select an operating system using the dropdown menu. 

Next, select a click location using the dropdown menu. This will reveal a myriad of options to choose from. 

Based on the operating system and click location you have selected, you’ll see the click redirect outcome for when a user does and does not have the app installed. For example, this Branch link clicked on an iOS device on Safari would open the app for users who have it, and users who do not have the app will be redirected to the iOS Deepview template configured in the Branch Dashboard. 

The Details column to the right shows additional information about why that click redirect outcome would occur based on the current configurations of the link and the SDK setup for the app.

Finally, the Link Details section will show you all of the properties associated with your link –– aka the link data. If you are ever wondering if a link was configured with the correct data, this screen is a great place to check to see if the expected data is there and if it contains the correct value. 

While this step provides an understanding of how the link will behave in different scenarios across operating systems and platforms, you’ll still want to test the Branch link on your device. 

Step 5: Test the behavior of a Branch Link on device

The best way to test your SDK setup and link configurations is to test a Branch link on your device. To do so, add your device to the Test Devices section of the Branch Dashboard. This will allow you to reset the device ID to simulate a first-time user flow and mark any data during the sessions as test data so that it doesn’t muddle your production metrics. In general, it is best to check the following use cases at a minimum when you are preparing to launch your Branch integration:

• Remove the app from your device and reset your advertising ID. Click the Branch link, then load the app with the Branch SDK. After you complete onboarding, ensure that you were routed to the correct screen in the app. 
• With the app installed, click the Branch link. Ensure that the app opens when the link is clicked and that you are routed to the correct screen based on the link data and deep link routing logic coded into the app. 

By using the steps detailed in this blog post, you’ll be able to thoroughly test out your Branch integration and validate that users who click on Branch links from different scenarios experience a great UX. 

Have questions? Reach out to your account team. 

Want to learn more about getting started with Branch? Request a demo!

The post How To Validate Your Branch Mobile SDK Integration appeared first on Branch.

If you’re a mobile gaming company, chances are a large portion of your focus (and spend) is dedicated to user acquisition and user retention. In this blog post, we’ll dive into strategies to acquire new mobile game users and explore which app features keep users coming back for more. By using Branch to power your mobile game marketing, you can deliver excellent player experiences and expand your userbase. 

Power your user acquisition with Branch

Use the tips below to spread the word about your mobile game while providing players with unique and interesting experiences.

User acquisition level 1: Content sharing

Branch provides several content sharing features that help you promote your mobile game, including the ability to share screenshots and deep links. For example, imagine a player just completed a milestone, like finishing a level or defeating a boss. This is an opportune time to prompt a user to share their achievement on social media. With the Branch SDK, you can easily provide users with a share button that automatically captures an in-game screenshot and generates a Branch link that they can share via text, social media, etc. 

The benefit of sharing a Branch link is that any user who clicks on the linked screenshot and does not yet have your mobile app installed will be taken directly to the app store to download it, creating a seamless user acquisition flow. By strategically utilizing Branch’s screenshot sharing feature, you can provide players with a simple way to share their victories with friends, while also acquiring new users whose interest is piqued by the engaging content. 

User acquisition level 2: Unlocking unique content

Another way to drive users into your app is to entice them with unique content available upon install. For instance, if users register for your game using a specific promo link, you can offer them bonus in-game currency. Branch links make these types of offers possible with the ability to specify an alias — a unique identifier displayed at the end of the link — that you can leverage for branding. 

Or perhaps you want users to gain access to a character that is only available if the app is installed through a specific promotion. With Branch’s QR code API, you can display an image of the character in the center of a QR code and automatically unlock it once the QR code is scanned to install the app. If you have physical stores or marketing material, leveraging custom branded QR codes is a quick, effective way to get users into your app. Don’t forget to reward them with some promotional content to sweeten the deal!

User acquisition level 3: Rewarded referral system

Rewarding users for referring their friends to download a game leverages your existing userbase to drive more users into your app. Be sure to check out this blog post for an in-depth look at building out a referral program for your mobile app. 

In the context of mobile gaming, you can reward both the referrer and the referee with bonus content like in-game currency and promotional content. If your game happens to be multiplayer, players will naturally want to play with their friends, so you should capitalize on this opportunity to reward users for their loyalty while building your fanbase.  

Use Branch to take user reengagement to the next level

Half the battle is getting users into your app, but the other half is retaining those users. Utilize the pro tips below to maximize the frequency at which users reengage with your app. 

Reengaging users level 1: Push notifications

Push notifications are an ideal way to bring users back into your app. When users tap a push notification, they are taken directly into the app to resume their activity. By sending tailored and timely messages about new collectibles, missions, or content, you boost the chances that users will reengage. 

Branch links make push notifications even more effective by deep linking users directly to relevant in-app content. For example, if a push notification mentions a new item available in the in-game store, a Branch-link-enabled push notification will open the app and take the user directly to the store screen, rather than dropping the user on the homescreen. By embedding Branch links into your push notifications, you can drive more seamless and holistic user experiences. 

Reengaging users level 2: Tasks and missions

Providing players with a list of tasks or missions to choose from, along with rewards for completing each task, gives players agency and avoids linear gameplay. Branch takes this approach to the next level by tracking events to provide detailed insight into which tasks are most popular among players and how far they progress on certain missions. Branch provides standard events like Achieve Level and Unlock Achievement, but you can also create and track custom events through the Branch SDK. 

Pro tip: Incorporate tasks that reward users for sharing content on social media to grow your userbase and keep existing users engaged as they pursue in-app rewards. 

Reengaging users level 3: Daily rewards system

Want to increase your 30-day user retention metric? One way to do this is to create a daily rewards system. Each day that a user logs into the app, they get a small reward. If they log in for 30 consecutive days, they get a big reward, in addition to all the small rewards they’ve earned along the way. If they miss a day, the count starts over at one. This builds a habit for the player to open the app at least once per day, making it more likely that they’ll do so even after they receive the 30-day prize. And who knows? Maybe a 60-day or 90-day prize will be waiting for them next! 

Acquire and reengage mobile game users with Branch

Branch’s mobile SDK can take your game to the next level by helping you acquire new users, reengage existing ones, and stand out among the vast amount of competition. Get creative with the ways users can unlock and share content in the app, and be sure to reward users for referring their friends. 

Want to learn more? Check out our How To Increase User Value in Gaming Apps webinar, or request a demo with our team.

The post Level Up Your Mobile Game With Branch appeared first on Branch.

Branch links can be used to engage users and take them to content of interest. The attribution data from those link clicks can be sent to Twilio Segment where it is used to segment cohorts of users. From there, Branch allows you to deliver experiences tailored to the interests and past activities of a user. By leveraging Branch’s Data Integrations with Twilio Segment you will accurately attribute conversions, optimize your ad spend, and increase your ROI.

Fragmented attribution leads to broken user experiences

In order to understand the critical role that both Branch and Twilio Segment play in the mobile ecosystem, we first need to examine the challenge of how mobile attribution has become so fragmented over the years. 

With the web, attribution used to be simple: 

• Users clicked links to take them to their desired content within their browser.
• Tags could easily be added to links so that clicks would get attributed to that users’ web session. 
• And finally, browser cookies allowed for user tracking, which made it easy to deliver personalized user experiences based on the past activity and interests of the user.

While restrictions on device-level identifiers like the IDFA are meant to increase user privacy, they also make performing attribution and delivering a customized UX much more difficult. Google has announced its Privacy Sandbox changes, which will effectively be the Android equivalent. 

When you can’t determine that the user who began the journey on your website is the user who installed your app, it is not possible to facilitate deferred deep linking to take the user to the content of interest after they installed it. This results in less-than-ideal user experiences which leads to user frustration and drop-off. Conversely, if a user were to be deep linked to the content of interest after installing the app, it would improve their UX and lead to better retention. 

It’s more difficult than ever to perform attribution and deliver the seamless, personalized user journeys that make for a great user experience, and that is where Branch and Segment come into the picture as the solution. 

Supplement your Twilio Segment data with Branch’s attribution data to personalize the user journey

Branch is a cross-platform solution that powers deep linking and attribution. This makes sure your users are taken to the content of interest regardless of what channel they are on. Furthermore, it also can accurately measure which channels are leading to user acquisition and engagement. 

Twilio Segment is a customer data platform (CDP) that enables you to view all of your data from the variety of tools your team uses all in one place. By using Branch and Twilio Segment together, you can maximize insights into attribution data. Using Branch links in all of your campaigns across channels will greatly improve both their user experience as well as your attribution insights into their user journey into, and through, your app. 

When a Branch link is clicked, the app will open and deep link users directly to the content of interest if they have the app. Users without the app can be taken to the app store where they can install the app and then get taken to the content of interest, or you can choose to route them to mobile web content.

Branch links power seamless, cross-channel experiences for your users and supplements your existing data with additional attribution data to give you deeper insights into the user journey. 

That attribution data, along with any down-funnel events the user performs, will get forwarded over to Twilio Segment, enabling you to unify your data and leverage it as your source of truth for your analytics. You’ll be able to track installs and in-app events, such as purchases and sign-ups, and attribute them to the right marketing channel. All of this gives you full cross-platform insights into the user’s journey. 

You can then act on these insights, ingesting Twilio Segment data back into Branch where you can use it to deliver personalized experiences.

From there, the data can be segmented and used to send targeted user campaigns customized for different cohorts. This becomes a virtuous cycle that has the potential to power your app’s growth and deliver real, meaningful impact to your KPIs.

Branch provides two integrations with Twilio Segment, allowing you to:

• Export Branch data to Twilio Segment
• Import data into Branch from Twilio Segment

Importing the events you are currently tracking in Twilio Segment into Branch allows you to append Branch attribution data to those events, which you can use to attribute downstream conversion events like purchases across web and app to Branch link clicks. You can view and use those events anywhere you normally would Branch events in spots like the Liveview, Data Exports, Analytics Views, and more.

By exporting your Branch data to Twilio Segment, you will get insights into how Branch is driving new users into your app, and begin to understand the power of Branch as an acquisition pathway. 

You can also continue to leverage Twilio Segment as your source of truth for your data. This means that you have the ability to view all of your data in one spot: the Twilio Segment dashboard.

Furthermore, you can use the data exported from Branch into Twilio Segment to build custom audiences, enabling you to drive more personalized user experiences and construct user journeys that lead to more user acquisition and retention.

This partnership between Twilio Segment and Branch is changing the game for marketers. By integrating these platforms, you get a more comprehensive view of your customer journey, attribute conversions more accurately, optimize your ad spend, and increase your ROI.

Best practices: Increase insights and multiply your ROI

These are our best practices you can follow to ensure your success when integrating Twilio Segment and Branch: 

First: Make sure you have a clear understanding of your customer journey and touchpoints.

Specifically, you want to ensure that you track events at key points in the user’s interaction with your app, so that you can get the most insights out of the events you track and understand where to leverage customized user experiences tailored to the user.

Second: Use consistent naming conventions for your campaigns and events.

This will ensure that the nomenclature on the Branch and Twilio Segment dashboard aligns, and will keep your team from getting confused if different names are used for the same event across the two platforms. It also makes querying the data later on to view campaign performance and other metrics much easier if you decide on naming conventions and stick to them.

Third: Test your integration thoroughly before launching it.

You may think this a no-brainer but you’d be surprised! Make sure that you are able to see the expected events on the Twilio Segment dashboard and the Branch dashboard. You can also utilize the Branch liveview to verify that the events from Branch are being ingested correctly by Twilio Segment by checking the webhook response codes.

Fourth: Don’t track duplicate events with both Twilio Segment and Branch.

While being able to import and export events between Twilio Segment and Branch is very powerful functionality, with great power comes great responsibility. Make sure that you aren’t tracking the same event twice between the platforms or your analytics will become cluttered and misleading! 

Lastly: Be sure to add the segment_anonymous_id to your events.

This way, Twilio Segment can securely ingest them. Without this crucial step followed, Twilio Segment won’t ingest the events!

Interested in learning more about using Branch and Twilio Segment in your app? Be sure to check out our documentation on Importing Twilio Segment Events into Branch, Exporting Branch Events to Twilio Segment, and this webinar recording on Creating Streamlined Customer Journeys hosted by Branch and Twilio Segment. 

The post Engage Your Users and Unify Your Data With Branch’s Twilio Segment Integration appeared first on Branch.