What to Consider when Integrating BLE in your React Native App

Published: July 12, 2020

9 min read

Last updated: May 2, 2022

Bluetooth Low Energy (or simply BLE) devices are extremely popular these days. We, at Stormotion, we have already worked on a few projects involving BLE devices: one regarding vaping and another β€” fitness tracking devices.

In this article, we will specifically focus on the integration of BLE devices in React Native. However, how is this technology different from classic Bluetooth? And what are its key concepts? A brief explanation is below!

πŸ“³ Bluetooth Low Energy: The Main Concepts and Difference from Classic Bluetooth

We all know what Bluetooth is β€” a short-range wireless networking protocol that quickly connects devices. Currently, it has 2 versions: Bluetooth Classic and Bluetooth Low Energy.

  • Bluetooth Classic is often referred to as just Bluetooth. This technology can support continuous connections and transfer big amounts of data. This might include phone calls, audio streaming, and data.
  • Bluetooth Low Energy is also known as BLE. This is a version of Bluetooth that is adapted to low power sensors and accessories. Such devices, often used in IoT prototypes due to their long battery life, don’t require continuous connection. They are especially popular in the fitness, healthcare, security, home entertainment industries, and beacons.

What are the main terms you need to know when working with this technology? Check below!

Key concepts for BLE πŸ“–

Before you move on to the integration of BLE in a React Native App, it’s important to know how this technology works. We won’t focus on that too much but will still review some key concepts.

GATT stands for Generic Attribute Profile that defines how BLE devices transfer data. To make data transfer possible, devices should have a dedicated connection.

BLE devices are often referred to as peripheral devices, while smartphones, tablets, and other similar gadgets β€” as central devices. Every peripheral device can have an exclusive connection with one central device at a time, while the central device can be simultaneously connected to multiple other peripherals:

Connection between a central and peripheral devices

Connection between a central and peripheral devices (image by Kevin Townsend)

Since we’re talking about GATT, let’s take a closer look at the server/client relationship:

  • From that perspective, the peripheral device is known as the GATT Server that contains data.
  • The central device acts as the GATT Client that sends requests to the server.

The Client initiates all the transactions by asking the Server for data. There are 2 ways to transfer data from the Server to the Client: Notifications and Indications.

  • Notification is a one-way message. It's faster since it doesn’t ask the Client whether they've received the message.
  • Indication describes the system of two-way communication. The Server sends a message ➑️ the Client receives the message and sends a confirmation message back to the Server ➑️ thus, the Server knows that the initial message has reached the Client.

Data transfer itself is based on a few high-level objects: Profiles, Services, and Characteristics.

The hierarchy of Profiles, Services and Characteristics

The hierarchy of Profiles, Services and Characteristics (image by Kevin Townsend)

  • Profile is a predefined set of Services.
  • Services break up data into logic blocks that consist of Characteristics.
  • Characteristic is a single data point, including an array of related data like X/Y/Z values from a 3-axis accelerometer.

Here's an example of how it may look for a fitness tracking device:

Example of Profile structure

Example of Profile structure (image by Mohammad Afaneh)

If we break down the example above into smaller pieces:


Blood Pressure


Blood Pressure Service

Device Information Service


Intermediate Cuff Pressure
Blood Pressure Measurement
Blood Pressure Feature

Manufacturer Name String
Hardware Revision String
Model Number String

You can read a bit more on GATT, Profiles, Services and Characteristics here, and on Notifications & Indications β€” here.

Nevertheless, let’s get back to today's main topic!

βš™οΈ 2 Main Libraries for BLE Integration in React Native

As of July 2020, there are 2 libraries that can be used to integrate BLE devices into your React Native application:

  • react-native-ble-plx
  • react-native-ble-manager

❗️ Important note: this article is based on v.7.3.0 of react-native-ble-manager and v.2.0 of react-native-ble-plx

Let’s take a closer look!

πŸ›  react-native-ble-plx

GitHub | Documentation | Wiki

React Native BLE PLX is one of the 2 libraries you can use to work with this technology. It supports all the key features:

  • observing the adapter state of the device’s Bluetooth;
  • connecting to peripherals;
  • scanning BLE devices;
  • discovering services;
  • discovering, reading and writing characteristics;
  • observing indications & notifications;
  • negotiating MTU;
  • reading RSSI;
  • working in background mode on iOS;
  • turning on the Bluetooth adapter of the device.

Yet, the library doesn’t support the following features:

  • peripheral support that enables the communication between phones through BLE;
  • creating bonds with peripheral devices;
  • working with Bluetooth Classic devices.

The new (2.x) version of the library supports all the latest RN versions starting from 0.60. However, you can still use the old version of the library even up to 0.60.5 RN version, but with additional changes.

As for OS versions, the library works on iOS 9+ and Android API 19+.

βš’ react-native-ble-manager


This library is an alternative option you can use to integrate a BLE device into a React Native application.

Despite the fact that an explicit list of features isn’t provided, we have defined the key functionality based on the names of methods. It includes all the features react-native-ble-plx has and a few additional ones such as:

  • bonding peripherals;
  • requesting connection priority;
  • getting connected & bonding peripherals.

The latest version of the library supports RN 0.60 and newer. However, the older version of the library can be used with older RN versions:

  • React Native 0.40-0.59 is supported until 6.7.X
  • React Native 0.30-0.39 is supported until 2.4.3

As for OS versions, this library covers iOS 8+ and Android API 18+.

Read Also

React Native vs Flutter: Detailed Comparison

βš– react-native-ble-plx vs react-native-ble-manager Comparison

We’ve also made a few comparison tables to cover the main differences between the two libraries:

βœ… Compatibility



πŸš€ RN version



🍎 iOS version



πŸ€– Android version



If we take a look at the features, it's noticeable that react-native-ble-manager provides a bit more possibilities for developers:

βš™οΈ Features




observing device's Bluetooth adapter state



scanning BLE devices



making connections to peripherals



discovering services/characteristics



reading/writing characteristics



observing characteristic notifications/indications



reading RSSI



negotiating MTU



background mode on iOS



turning the device's Bluetooth adapter on



communicating between phones using BLE (Peripheral support)



bonding peripherals


βœ… (Android only)

checking if specific peripheral is connected



getting bonded peripherals


βœ… (Android only)

getting connected peripherals



refreshing cache

βœ… (Android only)

βœ… (Android only)

requesting connection priority


βœ… (Android API 21+ only)

Written in TypeScript



Finally, we can also compare some GitHub stats:

πŸ“Š GitHub Stats (on 12.06.20




⭐️ Stars



⚠️ Issues



🍴 Forks



πŸ‘¨β€πŸ’» Contributors



πŸ‘©β€πŸ’» Used by



πŸ’» Commits



In general, react-native-ble-plx is more popular among developers:


You can find even more smaller details on react-native-ble-plx here, and on react-native-ble-manager here.

βœ… Apps to Test BLE Devices

When developing a React Native mobile app with BLE integration, you should test how it will actually function with such devices. Our team used the following apps:

These tools are quite similar and provide many options to test different features of BLE devices.

Read Also

18 Essential Tools For React Native Development

⚠️ Possible Pitfalls when Integrating BLE Devices

During BLE integration, our developers spotted a few pitfalls that can make the development process a lot trickier. Here are our recommendations on how you can make the development go smoother.

# 1: Turn on geolocation 🌍

If you’re developing an Android application, this one will be important. As written in this documentation: β€œStarting from Android API 23+, to access the hardware identifiers of nearby external devices via Bluetooth and Wi-Fi scans, your app must now have the geolocation enabled”.

To check whether the geolocation is enabled and turn it on in case it isn't, we recommend using the react-native-android-location-enabler library.

# 2: Turn on Bluetooth πŸ“³

Obviously, you need to turn on Bluetooth on the device before scanning. For this purpose you may use the methods of the mentioned libraries:

# 3: Change device name πŸ“±

When using react-native-ble-plx, you may stumble upon a bug which will prevent you from being able to change the device name. That can happen in case the name is cached. This issue is tracked here.

# 4: Keep code quality high πŸ†

Finally, here are a few general tips to improve the code quality:

  • Keep all of the characteristics and UUID services in one place.
  • Avoid magic numbers in characteristics. Instead, use constants.
  • Organize the logic structure into 2 separate files:
    • one file to keep the logic that contains code that isn't related to communication with a specific device (e.g. scanning, connection, disconnection);
    • another file for the code that contains communication with a specific device β€” discovering services/characteristics, observing notifications/indications, reading/writing characteristics, etc.

Read Also

11 Stories of How React Native Apps Have Changed the World

πŸ’‘ Takeaways: So, Which One to Choose?

Simple but true: the best choice is always the one that matches your needs better than all the other options. Thus, we'd recommend you to consider things like:

  • the required features;
  • the RN version used in the project;
  • the OS versions you’d like to cover.

If you'll find out that both libraries suit you, we’d recommend choosing react-native-ble-plx, as it has a clearer and more structured documentation.

Get in touch!

Read also

How can we help you?

Our clients say

Stormotion client Max Scheidlock, Product Manager from [object Object]

They understand what it takes to be a great service provider, prioritizing our success over money. I think their approach to addressing ambiguity is their biggest strength. It definitely sets them apart from other remote developers.

Max Scheidlock, Product Manager