Bluetooth Low Energy (BLE) has become the backbone of modern mobile experiences, powering everything from fitness trackers and smart home devices to industrial sensors and healthcare equipment. For React Native developers building cross-platform mobile applications, integrating BLE functionality is essential for connecting to the growing ecosystem of IoT devices. The react-native-ble-manager library provides a robust, well-maintained solution for implementing BLE communication in your React Native apps, supporting both iOS and Android platforms with a unified JavaScript API.

This comprehensive guide walks you through everything you need to know to implement BLE functionality in your React Native applications, from initial setup and permissions to advanced operations like reading, writing, and subscribing to device notifications.

Understanding Bluetooth Low Energy Fundamentals

Installation and Configuration

Platform-Specific Permissions

Scanning for BLE Devices

Connecting and Pairing

Reading, Writing, and Notifications

Best Practices and Optimization

Understanding Bluetooth Low Energy Fundamentals

Bluetooth Low Energy, commonly known as BLE or Bluetooth Smart, is a wireless personal area network technology designed for short-range communication with minimal power consumption. Unlike classic Bluetooth, which was optimized for continuous data streaming, BLE is designed for intermittent data transmission, making it ideal for battery-powered devices that transmit small amounts of data periodically.

The BLE protocol operates on a client-server architecture where devices can take on one of two roles: central (client) or peripheral (server). In the context of mobile app development, your React Native application typically acts as the central device, scanning for and connecting to peripheral devices such as heart rate monitors, smartwatches, or IoT sensors.

BLE communication is built around three fundamental concepts: services, characteristics, and descriptors. Services organize related functionality into logical groups, with each service identified by a unique UUID. Within each service, characteristics represent individual data points or functionalities that can be read from, written to, or monitored for changes. Descriptors provide additional metadata about characteristics, such as user-friendly descriptions or configuration parameters. Understanding this hierarchy is essential for effectively working with any BLE device.

GATT Hierarchy Overview

The GATT (Generic Attribute Profile) structure organizes BLE communication into a clear hierarchy: The Central device (your smartphone) connects to a Peripheral device (sensor or wearable), which exposes one or more Services. Each Service contains multiple Characteristics that hold actual data values. Characteristics can have Descriptors for additional metadata like user descriptions or configuration settings.

Installation and Configuration

Installing react-native-ble-manager in your React Native project follows the standard npm package installation process. The library supports React Native's autolinking feature introduced in version 0.60, which means you typically don't need to manually link the native modules. For projects using React Native 0.60 or newer, simply installing the package is sufficient to get started, with iOS requiring one additional step of installing CocoaPods dependencies.

For React Native 0.76 and later versions, only the new architecture (Fabric and TurboModules) is supported, which means your project must be configured to use these modern rendering and module systems. This architectural shift brings significant performance improvements but may require updates to your existing code if you were relying on legacy native module patterns. Projects on React Native versions 0.60 through 0.75 support both architectures, offering greater flexibility during migration. If you're building a full-stack mobile application that includes both mobile and web components, ensuring consistency across platforms becomes an important consideration in your architecture decisions.

Installation Commands

# Install the package
npm install react-native-ble-manager
# or
yarn add react-native-ble-manager

# For iOS, navigate to ios folder and install pods
cd ios && pod install && cd ..

# Android requires no additional steps if using Expo or React Native CLI

Platform-Specific Permissions

iOS Configuration (Info.plist)

<key>NSBluetoothAlwaysUsageDescription</key>
<string>This app needs Bluetooth access to communicate with BLE devices.</string>
<key>NSBluetoothPeripheralUsageDescription</key>
<string>This app needs Bluetooth access to connect to nearby devices.</string>

Android Configuration (AndroidManifest.xml)

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />

Android requires runtime permission requests for Bluetooth functionality, and iOS also benefits from explicit permission handling to ensure a smooth user experience. Starting with Android 12 (API level 31), the BLUETOOTH_CONNECT and BLUETOOTH_SCAN permissions are required as separate runtime permissions. These new granular permissions give users more control over which Bluetooth capabilities they grant to apps.

Since BLE scanning can theoretically be used to determine a device's physical location, Android requires location permissions at runtime for BLE scanning to work correctly, even if your app doesn't use location data directly. Implementing proper permission management is essential for respecting user privacy and providing clear explanations for why your app needs certain capabilities. Users are increasingly aware of and concerned about app permissions, so presenting a clear, honest justification for Bluetooth access improves both your app's acceptance rate and user trust.

Scanning for BLE Devices

Scanning is the process of discovering nearby BLE devices by listening for their advertisement packets. When you start a scan, the BLE radio actively searches for devices broadcasting their presence, collecting information about available peripherals including their name, UUIDs, and signal strength (RSSI). Scanning is essential for discovering devices before you can connect to them, but it can be battery-intensive, so implementing scanning strategically with appropriate timeouts and filtering minimizes power consumption.

The scan method takes three parameters: an array of service UUIDs to filter by, the scan duration in seconds, and a boolean indicating whether to use legacy scanning mode. Filtering by specific service UUIDs improves scanning efficiency and reduces the number of irrelevant devices discovered, particularly in environments with many BLE devices present. Setting an appropriate scan duration balances device discovery with battery life; typically, 5-10 seconds is sufficient for most use cases.

Scanning for BLE Devices

import BleManager from 'react-native-ble-manager';

const startScan = async () => {
  // Clear cached devices before scanning
  BleManager.clearCachedAvailableDevices();

  // Start scanning with optional service UUID filter
  await BleManager.scan(['180D'], 5, false);

  // Add event listener for scan results
  BleManagerEmitter.addListener(
    'BleManagerDidUpdateValueForCharacteristic',
    handleUpdateValue
  );
};

const handleUpdateValue = (data) => {
  console.log('Received data from device:', data);
};

Connecting and Pairing

Once you've discovered a peripheral you want to connect to, establishing a connection is the next step in the BLE communication workflow. The connect method initiates a connection to the specified device, handling the complex negotiation process required to establish a BLE link. Connection attempts can fail for various reasons, including the device going out of range, being turned off, or already being connected to another device.

After a successful connection, you must call discoverAllServicesAndCharacteristics to retrieve the complete list of services and characteristics offered by the peripheral. This discovery process is necessary because BLE devices can offer many different services, and your app needs to know which ones are available before it can interact with specific characteristics.

Connection state management is an important aspect of BLE implementation, as connections can drop for various reasons beyond your control. Implementing reconnection logic allows your app to gracefully handle temporary disconnections, which are common in real-world scenarios involving mobile devices moving in and out of range of connected peripherals.

Connecting to a BLE Device

const connectToDevice = async (deviceId) => {
  try {
    // Connect to the device
    await BleManager.connect(deviceId);

    // Retrieve services and characteristics
    const peripheralInfo = await BleManager.retrieveServices(deviceId);
    console.log('Connected to:', peripheralInfo);

    return peripheralInfo;
  } catch (error) {
    console.error('Connection failed:', error);
  }
};

// Listen for connection events
BleManagerEmitter.addListener('BleManagerDidConnect', (data) => {
  console.log('Connected to device:', data.peripheral);
});

BleManagerEmitter.addListener('BleManagerDisconnectPeripheral', (data) => {
  console.log('Disconnected from device:', data.peripheral);
});

Reading, Writing, and Notifications

BLE characteristics are the fundamental units of data within the GATT hierarchy, representing individual values that can be read, written, or monitored. Each characteristic has a set of properties that define what operations are permitted, including read, write, writeWithoutResponse, notify, and indicate. Understanding these properties is essential for correctly interacting with BLE devices.

Reading a characteristic value retrieves the current value stored on the peripheral device. This operation is synchronous from your app's perspective but involves a request-response exchange with the peripheral, so there's a small latency involved. Reading is appropriate for obtaining the current state of a device or when you need an exact snapshot of a value at a specific moment. The read method returns a base64-encoded string representing the characteristic's value, which you'll need to decode according to the device's specification.

Reading Characteristic Values

const readCharacteristic = async (
  deviceId,
  serviceUUID,
  characteristicUUID
) => {
  try {
    const data = await BleManager.read(
      deviceId,
      serviceUUID,
      characteristicUUID
    );

    // Convert buffer to readable format
    const buffer = Buffer.from(data);
    const value = buffer.toString();

    return value;
  } catch (error) {
    console.error('Read failed:', error);
  }
};

Writing to Characteristics

const writeCharacteristic = async (
  deviceId,
  serviceUUID,
  characteristicUUID,
  value
) => {
  try {
    // Convert string to byte array
    const bytes = Array.from(value).map(c => c.charCodeAt(0));

    await BleManager.write(
      deviceId,
      serviceUUID,
      characteristicUUID,
      bytes
    );

    console.log('Write successful');
  } catch (error) {
    console.error('Write failed:', error);
  }
};

Writing to characteristics allows your application to send commands or data to the BLE peripheral. This operation is essential for controlling devices, configuring settings, or triggering actions on the connected peripheral. The write operation can be performed with or without a response, with the choice affecting reliability and latency differently.

Write operations without response offer lower latency but don't confirm that the peripheral received the data, making them suitable for operations where occasional packet loss is acceptable. Write operations with response provide guaranteed delivery but add latency and consume more bandwidth. Choose the appropriate mode based on your reliability requirements and the device's capabilities.

Each characteristic has a maximum write length defined by the BLE specification, and attempting to write more data than supported will result in an error. For larger data transfers, you may need to implement a chunking mechanism that breaks the data into smaller pieces and sends them sequentially.

Notifications and indications are mechanisms by which BLE peripherals can push data to the connected central device without requiring repeated read requests. The key difference between them is reliability: notifications are fire-and-forget, while indications require an acknowledgment from the receiver. For most use cases, notifications provide sufficient reliability with better performance, but indications may be necessary for critical data where guaranteed delivery is essential.

Before you can receive notifications, the characteristic must have the notify or indicate property, which is determined by the device manufacturer. Subscribing to these events is the foundation of building responsive applications that react to real-time data from connected devices. Real-time data from BLE devices often comes in the form of notifications, making this feature essential for applications like fitness trackers, heart rate monitors, or any device that continuously streams data to the connected app.

Setting Up Notifications

const startNotification = async (
  deviceId,
  serviceUUID,
  characteristicUUID
) => {
  try {
    // Enable notifications
    await BleManager.startNotification(
      deviceId,
      serviceUUID,
      characteristicUUID
    );

    // Listen for updates
    BleManagerEmitter.addListener(
      'BleManagerDidUpdateValueForCharacteristic',
      (data) => {
        const { peripheral, value, characteristic } = data;
        const buffer = Buffer.from(value);
        console.log('Received:', buffer.toString());
      }
    );
  } catch (error) {
    console.error('Notification setup failed:', error);
  }
};

const stopNotification = async (
  deviceId,
  serviceUUID,
  characteristicUUID
) => {
  await BleManager.stopNotification(
    deviceId,
    serviceUUID,
    characteristicUUID
  );
};

Best Practices and Optimization

Performance Optimization

Implement strategic scanning with timeouts to reduce unnecessary BLE radio usage. Use connection pooling and reuse rather than repeatedly connecting and disconnecting, as establishing a BLE connection involves a multi-step negotiation process that consumes time and energy. Filter scans to discover only relevant devices by specifying service UUIDs, reducing processing required for scan results.

BLE operations can significantly impact battery life if not implemented carefully. Limit scan frequency and duration, disconnect from devices when they're no longer needed, and batch data operations where possible. Implement appropriate scan durations and use scan filters effectively to reduce the time the BLE radio spends active, directly translating to reduced battery consumption.

Security Considerations

Implement proper pairing and bonding for secure connections. Encrypt sensitive data transmitted over BLE connections and validate device identity before establishing connections. For applications controlling physical access or sensitive systems, implement proper authentication and encryption handling to protect against unauthorized access and man-in-the-middle attacks.

Robust error handling is essential for BLE applications, as wireless communication introduces many potential failure points. Connections can fail due to range issues, device power state changes, or interference. Your application must handle all these scenarios gracefully, providing clear feedback and, where possible, automatic recovery.

Implementing comprehensive logging helps with both debugging during development and troubleshooting issues reported by users in production. Log important state transitions, operation results, and error details with sufficient context to understand what was happening when the error occurred.

Connection state management deserves particular attention, as BLE connections are inherently unreliable. Implementing automatic reconnection with exponential backoff helps maintain connectivity in challenging RF environments. For characteristics that require enabling notifications via the CCCD, the library handles this automatically, but some devices may have specific requirements or quirks in their notification setup.

Healthcare and fitness applications represent one of the most common applications of BLE in mobile development, connecting to wearable devices like heart rate monitors, smartwatches, or cycling sensors. These applications leverage BLE's low power consumption to enable all-day tracking without significantly impacting the device's battery life.

A typical fitness app implementation involves scanning for known device types (often filtering by specific service UUIDs like the Heart Rate service 0x180D), connecting automatically to previously paired devices, and setting up notifications for relevant characteristics. The app must handle the continuous data stream from sensors, updating the UI in real-time while batching data for efficient local storage.

Healthcare applications may require additional considerations around data accuracy, FDA compliance for medical devices, and secure handling of sensitive health information. Implementing robust connection management is critical when dealing with medical-grade devices that users depend on for health monitoring. The intersection of mobile development and healthcare technology creates opportunities for innovative solutions that improve patient outcomes through connected care.

Smart home applications use BLE to communicate with a wide range of connected devices, from light bulbs and locks to thermostats and sensors. The flexibility of BLE combined with its low power requirements makes it ideal for smart home devices that need to operate for months or years on small batteries.

A well-designed smart home BLE integration implements device discovery and pairing flows that are intuitive for non-technical users while handling the complexity of BLE pairing requirements. Connection security is particularly important for devices that control physical access, requiring proper authentication and encryption handling.

The user experience for smart home apps often involves managing multiple devices across different rooms or zones, requiring efficient scanning and connection management to provide responsive control without excessive battery drain. Implementing connection caching and intelligent pre-connection for frequently accessed devices significantly improves perceived responsiveness. When building connected IoT solutions, the BLE communication layer forms the foundation for seamless device interaction.

Industrial IoT applications use BLE for monitoring sensors, tracking assets, and controlling equipment in manufacturing and logistics environments. These applications often require more robust implementations than consumer apps, with features like reliable data logging, failover handling, and integration with enterprise systems.

Industrial BLE implementations often need to handle larger numbers of simultaneous connections and manage more complex data collection scenarios. The devices themselves may be designed for harsh environments and offer different feature sets than consumer-grade devices, requiring flexible implementation that can adapt to various device types.

Security considerations are heightened in industrial applications, where the data being collected or the equipment being controlled may have significant real-world implications. Implementing proper authentication, encryption, and access control for BLE connections helps protect against unauthorized access. Maintaining audit logs of BLE device connections and operations may be required for compliance purposes in regulated industries.

Retail and proximity applications use BLE beacons for indoor navigation, proximity marketing, contact tracing, and location-based services. These applications leverage the ability of BLE devices to transmit signals that can be detected by nearby smartphones, enabling context-aware experiences in retail environments.

Implementing beacon-based solutions at scale requires careful attention to beacon management, including deployment strategies, battery monitoring, and content updates. Privacy compliance is essential when collecting proximity data, requiring clear disclosure to users and opt-in mechanisms for participation.

Analytics integration helps retailers understand customer behavior patterns, foot traffic flow, and engagement with proximity-triggered content. The combination of BLE technology with cloud-based analytics platforms enables sophisticated measurement of marketing campaign effectiveness and customer journey tracking.

Implementing Bluetooth Low Energy in React Native applications opens doors to a wide range of connected device experiences, from fitness tracking and healthcare monitoring to smart home control and industrial IoT solutions. The react-native-ble-manager library provides a solid foundation for building cross-platform BLE applications that work seamlessly on both iOS and Android.

Success with BLE development requires attention to platform-specific requirements, particularly around permissions on modern Android versions. Implementing proper error handling, connection state management, and cleanup of resources ensures your application remains robust and performant over time. Starting with simple use cases like device discovery and basic data reading helps build familiarity before moving to more complex scenarios involving real-time notifications and multi-device coordination.

As the ecosystem of BLE-enabled devices continues to grow, developers who master these fundamentals will be well-positioned to create compelling mobile experiences that bridge the physical and digital worlds. Whether you're building consumer fitness apps, enterprise industrial solutions, or innovative smart home experiences, the principles covered in this guide provide a foundation for successful BLE implementation.

Ready to Build Your Connected Mobile App?

Our team specializes in developing cross-platform mobile applications with Bluetooth Low Energy integration for healthcare, IoT, and enterprise solutions.

LogRocket: Using react-native-ble-manager

CoderCrafter: Master BLE in React Native

react-native-ble-manager Official Documentation

Stormotion: React Native BLE Integration

Using React Native BLE Manager: A Complete Guide to Bluetooth Low Energy in Mobile Apps

Understanding Bluetooth Low Energy Fundamentals

Installation and Configuration

Platform-Specific Permissions

Scanning for BLE Devices

Connecting and Pairing

Reading, Writing, and Notifications

Best Practices and Optimization