How to Fast-track a Referral Program with Voucherify, Segment, Braze, and Branch?
Tags: marketingtechnology, architecture, api
Published: 2023-08-14 10:06:49

---
title: How to Fast-track a Referral Program with Voucherify, Segment, Braze, and Branch?
published: true
date: 2023-08-10 10:13:17 UTC
tags: marketingtechnology,softwarearchitecture,api
canonical_url: 
---

[Referral programs](https://www.voucherify.io/referral-programs) have long been hailed as one of the most effective marketing strategies to acquire new customers, increase customer loyalty, and boost revenue. However, running a successful referral program requires careful planning, execution, and the right set of tools to achieve optimal results. In today’s fast-paced digital landscape, leveraging the power of technology and automation is crucial to maximize the potential of your referral program.

In this post, we will explore how you can fast-track your referral program using the powerful combination of Voucherify, [Segment](https://www.voucherify.io/integrations/segment), [Braze](https://www.voucherify.io/integrations/braze), and Branch. These four cutting-edge platforms offer an integrated solution to build your referral campaigns in days. In this guide, I will recreate the success story of [Pomelo Fashion](https://www.voucherify.io/blog/how-pomelo-supercharged-their-promotions-with-voucherify-and-braze) and their award-winning low-code referral campaign.

### What were the rules of Pomelo’s referral program?

Pomelo Fashion created a highly personalized messaging experience by:

- Streaming user data into [Segment](https://segment.com/).
- Creating relevant referral messages in [Braze](https://www.braze.com/).
- Using [Branch](https://branch.io/) deeplinks to ensure that users land on the app page & app store.
- Leveraging [Voucherify](https://www.voucherify.io/) to deliver personalized messages and manage the referral codes.

![Pomelo referral program workflow](https://cdn-images-1.medium.com/max/1024/0*-S9XhjBXvCJD1CiU.png)

Pomelo launched a two-sided referral program which rewarded both the advocate and their friends. When it comes to the promotional logic, several requirements had to be met to ensure that the campaign drives customer acquisition while [preventing referral fraud and misuse](https://www.voucherify.io/blog/blowing-the-whistle-how-to-combat-referral-abuse-and-fraud):

- Friend is not an existing Pomelo customer.
- Friend uses advocate’s code to make their first Pomelo purchase.
- Friend gets 200 THB off their purchase.
- Advocate gets 200 THB coupon sent to their account EVERY TIME a new friend becomes a customer.
- Friends referrals should work on both web and mobile channels.

But the real difficulty had to do with Pomelo’s scale. As an industry leader, Pomelo serves millions of customers in a dozen different countries. The real challenge was to launch, and more importantly, maintain the marketing agility of the referral campaign across markets and teams in a limited time frame for launching the campaign.

### API-based building blocks of the referral campaign

Pomelo believes that with the right technology and marketing strategy, it’s possible to make personalization happen responsively, and at a massive scale.

As personalization today means crunching large volumes of customer data and synchronizing them across sparse systems and databases, Pomelo has become a power user of API-first platforms.

Here’s how they connected them to achieve:

- Faster time-to-market.
- Personalization flexibility.
- Traffic spikes handled.

Now, let’s get our hands dirty recreating this setup. Before we continue, make sure you have these provided:

- Voucherify, Braze, Branch, and Segment accounts (we need the API keys).
- [Postman](https://www.postman.com/) (or any other tool allowing you to send and receive HTTP requests). We’re going to use it to simulate an app and backend exchanging messages.

_Note: Follow these links to find API documentation of_ [_Voucherify_](https://docs.voucherify.io/docs/authentication)_,_ [_Segment_](https://segment.com/docs/connections/find-writekey/)_,_ [_Braze_](https://www.braze.com/docs/api/basics/)_, and [_Branch_](https://help.branch.io/developers-hub/reference/apis-overview).

_Note: if you want to brush up on Postman and operating API-first platforms in general, you can visit our introductory [_article_](https://www.smashingmagazine.com/2019/01/api-based-platforms-product-managers/)_._

_Note:_ [_here_](https://drive.google.com/file/d/14tM3DiYY32Y8junVabLTh5oKogdAV2S_/view?usp=sharing) _you can find the Postman collection of the requests we use in this tutorial._

### Step 1 — Populate users across platforms (Segment)

Before we jump into the referral logic design, we need to ensure the basics are in place. The first thing on the list is the **customer data integrity**  — we’ll make sure a customer gets identified properly on every platform.

**Learn more** : [Customer segmentation — how to ensure data integrity?](https://www.voucherify.io/blog/technical-aspects-of-customer-segmentation-part-2-data-integrity)

Let’s imagine a new user signing up to our shop. We need to populate this information to Braze, Branch, and Voucherify to make the customer data actionable. That’s a perfect task for [Segment](https://www.voucherify.io/integrations/segment). It provides a coherent abstraction for identifying customers, tracking their behavior on various touchpoints and distributing these data to relevant systems.

Off we go to Segment. We’ll create the first connection. The connection will receive data from an app or actually its backend (source) and will send it to Braze and Voucherify (destinations).

**Learn more** : [How to use Segment custom attributes to personalize promotions?](https://www.voucherify.io/blog/voucherify-and-segment-how-to-effectively-use-customer-attributes-for-personalized-promotions)

Go to **Sources** , add a new [source](https://segment.com/docs/connections/sources/) and choose [HTTP API option](https://segment.com/docs/connections/sources/catalog/libraries/server/http-api/). This allows you to fire HTTP requests to Segment’s severs from Postman. Name the source and optionally add labels to filter sources in the future.

![How to set up the source in Segment](https://cdn-images-1.medium.com/max/1024/1*fnwZ08RfeO3O3hLUGvAZ5Q.png)
_Set up the Source in Segment_

Let’s test the connection. Click on the source and copy your write key.

![Illustration showing how to copy the Write Key](https://cdn-images-1.medium.com/max/1024/1*XXDvILe51ohJuztPR2afKA.png)
_Copy the Write Key_

Now, open Postman and create a new API request.

- Change the method to  **POST**.
- Set URL to[https://api.segment.io/v1/identify.](https://api.segment.io/v1/identify)‍
- In the Authorization tab, select Basic Auth as TYPE and provide your Segment API key as Username.
- Go to Body, select Raw and JSON. Place the following snippet in the body:

```
{
  "userId": "jim@dundermifflinpaper.com",
  "traits": {
    "email": "mike+jim@voucherify.io",
    "name": "Jim Halpert"
  }
}
```

For simplicity, we’re using emails as customer identifiers and[email aliases](https://support.google.com/a/users/answer/9308648?hl=en) to test messages.

![Authorizing API connection](https://cdn-images-1.medium.com/max/1024/1*zd6gSYpSwKxCbMiXeRKUWw.png)
_Authorize API connection_

![An example of API request in Postman](https://cdn-images-1.medium.com/max/1024/1*JovxfuAe7Usij0b9aozuVQ.png)
_Exemplary API request_

The customer data above serves as an example. To test the Segment API connection, you need to provide userID, email address, and customer name. Now SEND the request. When you see _“success”: true_, open **Debugger** in Segment. You should see a confirmation that your source has received data from Postman.

![Checking the API connection in Segment](https://cdn-images-1.medium.com/max/1024/1*EFGh7sa_4GgSwXrEXnCfsQ.png)
_Check the API connection_

Now that we have the source listening for requests, let’s pass them to Braze and Voucherify.

#### Add Voucherify as Destination

- Go to **Destinations** and click Add Destination.
- Select Voucherify from the Catalog and configure the integration.
- Get your API keys and paste them into Segment. You can find your keys in the[Project Settings](https://docs.voucherify.io/docs/authentication) in the Voucherify dashboard. Make sure the API URL corresponds with your[Voucherify settings](https://docs.voucherify.io/docs/api-endpoints).
- Voucherify Application ID serves as Segment’s API Key. Voucherify Secret Key is Segment’s API Token.

![Voucherify integrations configuration](https://cdn-images-1.medium.com/max/1024/1*AN5tZ96s6tFPi4H-RPY_Dw.png)
_Configure Voucherify integration_

Next, switch on your destination and go to **Event Tester**. Select Identify as Event Type and Send Event. On the right hand side, you should see the confirmation that Voucherify has created a test user. Likewise, when you go to Customers in Voucherify dashboard, you should see the newly-created test user.

![Illustration showing how to test Voucherify destination](https://cdn-images-1.medium.com/max/1024/1*hU0dVgHo_Aq94fcpPbpbcw.png)
_Test the Voucherify destination_

#### Add Braze as Destination

Adding Braze destination is quite similar, here’s how the settings might look like (make sure your REST API key has User Data permissions). You will find the data you need in the **App Settings** in Braze.

![How to add Braze as a destination](https://cdn-images-1.medium.com/max/1024/1*ne8TswGc2PcRDg8Tr3j5zA.png)
_Set up Braze destination_

Now, the final task in this step is to activate the whole workflow. Ensure that both destinations are switched on, go back to Postman and hit SEND once again. Segment will receive the request and translate it in a way it’s digestible by Voucherify and Braze. As a result, the Jim Halpert should be visible on both platforms.

![How to test the Connection by sending an API request](https://cdn-images-1.medium.com/max/1024/1*fbLRTcmGKjUxd5-rsUWTCw.png)
_Test the Connection by sending an API request_

### Step 2 — Generate referral codes (Voucherify)

Now that we have our customers synced, let’s invite them to join the referral program. We’ll start off with generating referral codes with Voucherify. Begin by providing general details of your referral program.

- Create a new Referral Codes campaign.
- Define the name and the code pattern for our program (you might want to give a prefix and remove misleading characters like O, 5, I from referral codes).
- Impose some time limits, they’re optional but usually of high importance for the success of a campaign.

**Learn more** : [How to build a referral program?](https://www.voucherify.io/blog/how-to-create-a-referral-program-that-works)

![Setting up referral programme details in Voucherify](https://cdn-images-1.medium.com/max/1024/1*ZA217LEshVE3VTBYUMuzXQ.png)
_Provide general details of your referral program_

The third stage is essential. Here, we need to design on what conditions Voucherify should reward people. In our case, we want to give 200 THB to both advocate and new customer so we choose **double-sided reward**.

Now to the conversion event. By default, Voucherify awards advocates when their referral code gets[redeemed](https://docs.voucherify.io/docs/redemption). Sometimes, however, this isn’t enough to account for a successful referral. You might want to wait for the shipping or event return period. That’s why Voucherify enables you to define a custom event for this purpose (whenever Voucherify receives such an event via API, the valid referral is counted).

![How to choose referral program workflow in Voucherify](https://cdn-images-1.medium.com/max/1024/1*5jwH0EfjAvCsrE646wSk8w.png)
_Set up the referral program workflow_

We know when a customer gets awarded, but we’re still missing the actual reward. Proceed to the next screen to set it up. First, we define how we award referred friends — in our case it’s a discount coupon worth 200 THB.

![Creating referral rewards for invited customers](https://cdn-images-1.medium.com/max/1024/1*o0NN5dnw8tlouqd6rf1bCA.png)
_Create referral reward for invited customers_

At this point, we should think of some ground rules of the program. First, a friend should be referred only once. Second, we might want to increase the spend with minimal cart value for the referred customer’s first order. Finally, we can exclude customers from the program based on any attribute like location or payment method. Voucherify validation rules builder will help you achieve that with a simple editor.

Let’s skip Referrer Reward and Notifications steps (we’ll come back to them in a minute) and save the campaign. In this way, Voucherify will be ready to generate referral codes.

### Step 3 — Assign referral codes to user profiles (Braze)

It’s time to actually invite customers to the referral program. First, let’s call the Segment identify again to have at least two users. Here is an exemplary API call:

```
{
  "userId": "michael@dundermifflinpaper.com",
  "traits": {
    "email": "mike+michael@voucherify.io",
    "name": "Michael Scott"
  }
}
```

Next, let’s create a Braze campaign that calls Voucherify to get a unique referral code and assigns it to every new user. To do so, we’ll use [Connected Content](https://www.braze.com/docs/user_guide/personalization_and_dynamic_content/connected_content/).

- Create a new email campaign.
- Select your template and come up with an email copy.
- Switch to HTML editor and paste the following snippet somewhere within the <body> tag (preferably between <table> tags), substituting API credentials and the referral campaign identifier (get it from the URL in the Voucherify dashboard).

```
{% assign campaign_id = {{campaign.${api_id}}} %}
{% assign customer_id = {{${user_id}}} %}
{% assign source_id = campaign_id | append: customer_id %}
{% connected_content https://api.voucherify.io/v1/publications 
:method post 
:headers { "X-App-Id": "YOUR APP ID", "X-App-Token": "YOUR APP SECRET" } 
:body campaign=camp_YOUR_CAMPAIGN_ID&customer={{${user_id}}}&channel=Braze&source_id={{source_id}} 
:content_type application/json 
:save publication %}
```

- In the HTML editor, put `{{publication.voucher.code}}` where you want to display the code.
- Set up other parameters of the campaign and save it.

![How to leverage Braze Connected Content functionality](https://cdn-images-1.medium.com/max/1024/1*SWP9VUbhk7cLs0ucqKfWqw.png)
_Use Braze Connected Content functionality_

We’ve used Scheduled Delivery with immediate send-out. However, you can trigger the email send-out based on multiple events and attributes.

Once the campaign is launched, this happens:

- Voucherify generates a new unique referral code according to the pattern we defined.
- Voucherify publishes it to a user whose id is sent with Connected Content API call. (Once published, it won’t be used again for another user).
- Voucherify sends the new code back to Braze as a response to the API call.
- Braze puts the code in the right place and sends the email.

If everything worked as planned, we should receive emails and unique referral codes assigned to Jim and Michael in their Voucherify profiles.

![An example of referral email from Braze](https://cdn-images-1.medium.com/max/959/1*Vnqe0IU3AbNePxV4mHf_ag.png)
_Receive referral email from Braze_

![Referral code is assigned to customer in Voucherify dashboard](https://cdn-images-1.medium.com/max/1024/1*JBZAaPDYWyS0DtQrmsYd-A.png)
_A new referral code is assigned to Jim_

### Bonus step — upload codes to user profiles in Braze

Thanks to Connected Content, Braze was able to send the assigned referral code in a message. However, it won’t be persisted in the Braze user profile. You might want to upload it to have it at your fingertips for further campaign engagement.

To achieve this, you can configure the referral campaign to send corresponding referral codes via Custom Attribute.

- Let’s edit our referral campaign in Voucherify.
- Go to **Notifications** and select Send referral code to the referrer.
- Scroll down and select Braze as a channel. (You’ll need a Braze API key with users.track permission enabled.)
- Provide the name of Custom Attribute that will store the referral code.

![How to set up referral program notifications in Voucherify](https://cdn-images-1.medium.com/max/1024/1*D4B_EV8MgbtFx9NBRh03cg.png)
_Set up referral program notifications_

Save the campaign. From now on, every new Connected Call will populate the _referral\_code_ attribute of a user in Braze.

![How to store referral codes in Braze](https://cdn-images-1.medium.com/max/1024/1*F9VgIoNLY02QNh53pSz7oA.png)
_Use custom attributes to store referral codes_

### Step 4 — Create tiers for referrers (Voucherify)

Let’s wrap up the current setup. Thanks to Segment, every new user is synchronized with both Voucherify and Braze. Then, the active Braze campaign retrieves a unique referral code from Voucherify and sends it via email to the new user. The code is managed by Voucherify, it’s linked with the user and the promo engine treats it as a 200 THB off coupon for every new referred customer. You can validate the referral code to confirm this.

Create a new Postman request and call validate endpoint from Voucherify API.

- Select **POST** method and put the following URL: [https://api.voucherify.io/v1/vouchers/{CODE}/validate](https://api.voucherify.io/v1/vouchers/torchie-MYRATKCP/validate) replacing CODE with your referral code.
- Add X-App-Id and X-App-Token headers and fill it with Application ID and Secret Key respectively.
- Set Content-Type header to application/json.
- Set the following Body to simulate a friend trying to redeem the referral code and SEND.

```
{
    "customer" : {
        "source_id" : "pam@dundermifflinpaper.com"
    }
}
```

Voucherify should reply with the information about the referral code.

![How to validate the referral code in Postman](https://cdn-images-1.medium.com/max/1024/1*kfEAmPvcriiie6plDj27lg.png)
_Test validating the referral code_

What we’re still missing though is something that would move the needle — an actual incentive for advocates. Let’s give them 200 THB for every referred friend.

- Edit your referral campaign and go to **Referrer rewards**.
- Create the first and only tier which awards referrer every time referral event occurred. You can create many more to employ some gamification theme. Apart from the number of successful referrals you can add more validations rules, like location or budget to name a few examples.

![Creating a tier for referrer rewards in Voucherify dashboard](https://cdn-images-1.medium.com/max/1024/1*9qSpp6b0iCCSI-OEmPF80Q.png)
_Create a tier for referrer rewards_

Go to Rewards and CREATE NEW REWARD. Our plan is to give a 200 THB coupon for every referral. Name your reward to help you reference it in reports (something like “200 THB off”) and click CREATE NEW CAMPAIGN. Here select Amount type coupons of 200THB value and SAVE. Now ADD REWARD to assign reward to your referral campaign.

![How to confirm the referral reward in Voucherify](https://cdn-images-1.medium.com/max/1024/1*6m9gwVbDh7UxJYQwZV02ow.png)
_Confirm the referral reward_

The last step is to notify an advocate about the reward. To do so, we’ll send a reward coupon code to advocates profiles at Braze. Enable Braze channel and define how Voucherify should name the reward related Custom Attributes.

![Customer referal reward notifications](https://cdn-images-1.medium.com/max/1024/1*1qYKT6HfuKNQQESUHU3EDQ.png)
_Notify customers about referral reward_

Save the campaign and the Voucherify part is ready. It’s about time we tested what we’ve built so far end-to-end. We’ll simulate the scenario of Jim referring the service to his dear friend — Dwight. In effect:

- Dwight gets 200THB off of her first order.
- Jim gets a 200THB coupon reward.
- Dwight receives an invitation to referral program with a unique referral code.

**Switch to Postman and follow these steps:**

Dwight installs the app and creates an account — the backend detects a new signup — call Segment Identify request with the body below to notify Braze and Voucherify about a new signup. Go to dashboards in Voucherify and Braze to see if Dwight data got populated correctly.

```
{
  "userId": "dwight@dundermifflinpaper.com",
  "traits": {
    "email": "mike+dwight@voucherify.io",
    "name": "Dwight Schrute"
  }
}
```

Dwight uses the referral code at the checkout — the ecommerce engine needs to apply the code to the cart. Call [Voucherify Redemption](https://docs.voucherify.io/reference#redeem-voucher) to validate the referral code and to calculate the discounted order price.

```
{
    "customer" : {
        "source_id" : "dwight@dundermifflinpaper.com"
    },
    "order": {
      "amount": 80000 // amount multiplied by 100 to handle decimals
    }
}
```

![Redeeming the referral code with Voucherify API](https://cdn-images-1.medium.com/max/1024/1*3s3pzqdmCpEDj-q1A2a1Iw.png)
_Redeem the referral code with Voucherify API_

Dwight gets his first order delivered to the farm — the backend listens to the shipping status and notifies CRM platforms about the updates — call Segment Track Referral to notify that a successful referral should be counted.

```
{    
"userId":"dwight@dundermifflinpaper.com",    
"event":"referral",   
"referral":{  
"code":"torchie-MYRATKCP"    
}
}
```

When we look into the referral program dashboard, we should see two things:

- Jim’s referral code has been already used once (by Dwight).
- A newly generated code for Dwight.

![An illustration of referral codes status in Voucherify dashboard](https://cdn-images-1.medium.com/max/1024/1*1drsPiolsZycI6VwZrPiKQ.png)
_Visit the dashboard to see referral codes status_

When you visit Jim’s profile in Braze, you can see that he received his first referral reward coupon.

![An overview of the referral reward code in Braze](https://cdn-images-1.medium.com/max/1024/1*SkscXwUaqQ45NgZsL5qA5Q.png)
_You can see the referral reward code in Braze_

When you invite new users to the referral program again, Voucherify will generate Dwight’s referral code via Connected Content and send it to his profile in Braze.

The very last step is to notify Jim about the reward. The easiest way to achieve it is to create an action-based campaign which uses **Change Custom Attribute Value** trigger. So, whenever reward\_coupon\_code changes its value with successive reward notifications from Voucherify, Braze sends a message with the reward coupon code.

In a production environment, you might and should integrate in-app customer profiles with Voucherify to show their full promotional wallet, including referral code, statistics, and above all rewards. For the web version, you can use Voucherify pre-built cockpits.

![Customer hub with the referral score in Voucherify dashboard](https://cdn-images-1.medium.com/max/1024/1*ftIbOmZOwbaWJbvZd11k7Q.png)
_Visit individual customer hub to see the referral score_

### Bonus step — Add more tiers (Voucherify)

If the campaign performs too well, you can easily add more tiers to gamify the referral frenzy and protect your budget. For example, you might want to send one reward for one referred customer, and then another one but only if an advocate earns at least five referred customers — so two rewards in total regardless of the number of successful referrals. To apply this to your program, just edit your campaign, go to tiers section and:

- Edit the original tier, so that number of Referred Customers is more than 0.
- Create another tier, and set the condition to Referred Customers is more than 5.

![How to build additional referral tiers in Voucherify](https://cdn-images-1.medium.com/max/1024/1*4v-eovbeoFPlqoFI705RUA.png)
_Build additional referral tiers_

### Step 5 — Onboarding with deeplinks (Branch)

The missing puzzle is how we can attribute app installs to our referral campaign and how to send newly registered users the referral deal. With our current setup, the advocate has to send a referral code to their friends. Then, they need to save it somehow to paste in during the checkout stage. What if we could modify the referral link in a way it lets the app store and apply the code automatically?

To achieve this goal, we need deeplinks. Many of you already use one of the deeplinking platforms, you can use it here for integrity. In our case, we’ll go with Branch.

While Braze x Branch integration has[some](https://help.branch.io/using-branch/docs/universal-email-integration-guide) advanced goodies for branded deeplinking, this is beyond the scope of this tutorial. We’re going to use[long links](https://help.branch.io/using-branch/docs/creating-a-deep-link#long-links) to show how straightforward it is to attribute installations to our referral campaign and how to point new users to a specific view.

When our deeplink is clicked by a new user, Branch will redirect them to a corresponding place, either App Store, Google Store or a web page. Then, when the app is installed, the parameters that we pass with the URL, will be read by the Branch SDK on the mobile app. In this way, the app will be able to recognize the referral code and store it in the user’s profile. Here’s how our deeplink is constructed:

+ + +

Let’s implement it with Branch:

- Open your Branch dashboard and go to Configuration.
- Provide the links to the stores and a fallback link in for the web view. (As we don’t use real apps in this example, we skipped stored links).

![How to set up Branch redirects](https://cdn-images-1.medium.com/max/1024/1*1uVfeWbS0hHTwJIrw-eWQw.png)
_Configure Branch redirects_

Scroll down to Link Domain and set up your domain. (Again, for simplicity we use default ones).

![Using default link domain to test the workflow](https://cdn-images-1.medium.com/max/1024/1*1jb6ymf106slYaCExoDh3g.png)
_You can use default link domain to test the flow_

Open Postman, create a new GET request and type the following long link:

**_g9xol.test-app.link/?~campaign=referral&code=torchie-MYRATKCP&$fallback=https%3A%2F%2Fshowcase.voucherify.io_**

Before we click SEND, let’s analyze each part of our long link:

- **_g9xol.test-app.link_ ** — our Branch domain (you can configure your custom one for better branding).
- **_~campaign=referral _** — telling Branch how to attribute the click.
- **_code=torchie-MYRATKCP_ ** — Jim’s referral code.
- **_$fallback=https%3A%2F%2Fshowcase.voucherify.io_ ** — (optional) telling Branch where to redirect the user after click in the fallback mode (we’ve set up the primary mode in Branch dashboard).

Now, when you hit SEND, simulating a user clicking on the link, the request goes to Branch which will redirect the user to the right place.

![How to send a test API call to Branch](https://cdn-images-1.medium.com/max/1024/1*bsZGYCKUMah_TCZQHEwJJg.png)
_Send a test API call to Branch_

When you open Source and compare by campaign, you’ll see that the click was correctly attributed to our referral campaign.

![How to test Branch click attribution](https://cdn-images-1.medium.com/max/1024/1*fvKsy-bxyCQoyLFJX70VYg.png)
_Test Branch click attribution_

Now, go back to the Braze referral invitation campaign and add our link to the message. **In the URL, remember to replace Jim’s code with `{{publication.voucher.code}}` to ensure every signup gets their own unique code.**

### Step 6 — Manage your referral campaign

In these five steps, we’ve created a **complete POC of a solid referral program**. Thanks to powerful mar-tech tools, we were able to spin off a highly targeted referral campaign in hours. The API-first approach allowed us to outsource the backend part while still having flexibility over the mechanics of the referral calculation. What’s most important, with the collaboration between Braze, Segment, Branch and Voucherify you can enjoy 100% personalized, on-brand experiences with app and web customer touchpoints.


The best part? Lower development efforts required. Both of the implementation part and maintenance. With Voucherify, you can change the referral program conditions on your own. Think running A/B tests with limiting referrals per advocates or referrals in total, adding minimum spent value to the friend’s order, or excluding specific customers or whole segments from the program.


The final step is to define the requirements for your developers. Within a day or so, they should be able to translate our Postman requests into the production code (check out official SDKs). The initial launch might require some bulk customers sync and depending on your traffic you should consider the rate-limiting policies of the platforms — this is where the official API documentation comes in handy.


With Voucherify and your mar-tech stack you can launch many more personalized incentives. Visit our [docs](https://docs.voucherify.io/docs) to learn what goodies come with our API, get our Postman collection, and happy hacking!