# react-native-ble-manager: a direct Bluetooth Low Energy bridge for React Native

> A JavaScript library that hands Bluetooth Low Energy calls to the native iOS and Android stacks, with a support matrix that tracks React Native versions and a codegen workflow.

**innoveit/react-native-ble-manager** — React Native BLE communication module

- Repository: https://github.com/innoveit/react-native-ble-manager
- Website: http://innoveit.github.io/react-native-ble-manager/
- Stars: 2,332 · Forks: 797
- Language: Java
- License: Apache-2.0
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/innoveit-react-native-ble-manager

## A thin wrapper that assumes you understand the platform split

The README is blunt about what the library is and is not. It describes itself as a simple connection with the OS APIs, and then makes the point that the BLE stack is standard in principle but frequently behaves differently depending on the device, the operating system and the peripheral it connects to. That framing matters more than a feature list would, because it sets expectations before you file an issue.

The instruction that follows is practical advice rather than a policy: before opening an issue, verify that the problem is really the library. With 797 forks and 2,332 stars, the repository has accumulated a large body of hardware specific reports, and a good share of them trace back to a phone chipset or a peripheral firmware rather than to the bridge itself.

The project's origins are noted honestly. It was originally inspired by the Cordova plugin for BLE central, which explains the API shape: functions named after the operations rather than a managed queue with its own scheduling layer. If you have written against that Cordova plugin before, the naming will feel familiar.

## The support matrix is the first thing to read

Instead of a vague compatibility promise, the README gives a version mapping table that tells you which library line serves which React Native generation, and it pairs each with an end point:

```
RN 0.76+ only the new architecture is supported

RN 0.60-0.75 supported until 11.X  
RN 0.40-0.59 supported until 6.7.X  
RN 0.30-0.39 supported until 2.4.3  
```

That last column is the useful one. It is saying that if you are still on an older React Native, you will be pinning to an old major version of this library and you will not be getting fixes, because the maintainers have moved on. The top line matters just as much: on React Native 0.76 and above only the new architecture is supported, which reflects React Native's own move away from the legacy bridge.

Platform floors are given too: iOS 15.1 or newer and Android at API level 23 or above. Neither is aggressive, which suggests the library is not trying to hold back old devices for its own sake.

## Installing is one npm command with autolinking

The install step is exactly what you would hope for:

```shell
npm i --save react-native-ble-manager
```

There is no manual linking step because the library supports React Native's autolink feature. The repository carries `react-native.config.js` and an `RNBleManager.podspec` at the root, and the package manifest lists `/android` and `/ios` among the published files, which is what lets both native projects resolve the module once the package is installed.

The npm metadata in `package.json` is worth a glance if you are auditing the package. It is published under the Apache 2.0 license with Innove credited as the author, and the manifest declares three entry points: a CommonJS build at `dist/cjs/index.js`, an ES module build with types at `dist/esm`, and a React Native specific entry pointing at `src/index.ts`. That last one means Metro resolves the TypeScript sources during development while package consumers get the compiled output, which is a common and sensible split.

## Running the bundled example is the fastest sanity check

The README recommends pointing your app registry at the shipped example component to try the library, and it flags the catch in the same breath: the `example` directory only exists when you clone the repository, so the import will not resolve from `node_modules`. In other words, this is a developer workflow, not something you can copy into an application.

```javascript
// in your index.ios.js or index.android.js
import React, { Component } from "react";
import { AppRegistry } from "react-native";
import App from "react-native-ble-manager/example/App"; //<-- simply point to the example js!
AppRegistry.registerComponent("MyAwesomeApp", () => App);
```

There is also a separate link to the example directory for browsing the source. The tree confirms this is a real React Native app rather than a stub: the example project has its own `package.json`, `metro.config.js`, `app.config.js`, a `Gemfile`, a `components/` directory and its own `__tests__/`.

The value of running it early is that BLE problems are notoriously hard to isolate. Knowing whether scanning finds your peripheral before you write a line of your own logic saves a lot of time.

## Building from source and regenerating the native specs

The library is written in TypeScript and compiled before use, and the README is explicit that a build has to happen at least once for the example project to work, because the example consumes the outputs listed as entry points in the manifest:

```shell
npm install
npm run build
```

While iterating on files under `src/`, a watch mode is available instead. If you change the native counterparts under `android/` or `ios/`, neither is enough on its own and you have to rebuild the whole app for your target platform. That three speed tier split, TypeScript only, native code, and full app rebuild, is a reasonable summary of where the friction lives in React Native native modules.

The newer part is the codegen section, which reflects React Native moving spec definitions into JavaScript and generating the native bindings. Generating the Android side takes three steps, beginning with an Expo prebuild in the example folder and then a Gradle codegen task:

```shell
npx expo prebuild --platform android
```

The iOS side is shorter because codegen runs during the first build, and you only need to run `pod install` again to force it. The Gradle cache hint about stopping the daemon and removing the cache directory is the kind of note that only exists because someone hit the problem repeatedly.

## What the repository contains beyond the bridge

The tree has the expected shape for a mature native module: `android/`, `ios/`, `src/`, `docs/`, `example/`, plus `plugin/` and `app.plugin.js` at the root, which indicate Expo module support alongside standard React Native. There is a `SECURITY.md`, a `CODE_OF_CONDUCT.md`, `dependabot.yml` for dependency updates and `tea.yaml`, a configuration file used by the Chainguard analysis tooling that some supply chain hardening setups use.

The release history shows a steady line rather than bursts. Version 12.5.3 shipped on 2026-09-21 with an Android fix forwarding GATT status on remote disconnect. Version 12.5.2 on 2026-09-07 skipped an explicit Kotlin plugin registration that newer Android Gradle Plugin versions already handle. Version 12.5.1 on 2026-07-06 fixed a case where disconnecting failed on Android.

Read together, those three releases are a good description of maintaining a BLE module in 2026: small platform specific corrections, arriving every few weeks, each one narrow. The full API documentation lives on a separate documentation site rather than in the repository, and the README's documentation section links straight to it.

## Conclusion

The useful thing about react-native-ble-manager is that it refuses to paper over the platform split. The README states which React Native versions map to which library line, names the minimum iOS and Android versions, and tells you to verify the BLE stack itself before blaming the library. Getting the example app running with a pointer to the bundled component is the fastest way to confirm your device and setup behave, and the docs site at innoveit.github.io carries the API reference the README leaves out. If you need Bluetooth classic rather than low energy, or you want a library that owns its own queueing and retry policy, this one leaves that to you.

## FAQ

### Which React Native versions does react-native-ble-manager support?

The README maps React Native versions to library lines. React Native 0.76 and above is supported on the new architecture only, 0.60 to 0.75 is supported until version 11.X, 0.40 to 0.59 until 6.7.X, and 0.30 to 0.39 until 2.4.3. Older React Native versions are pinned to older majors of this library.

### How do I install react-native-ble-manager?

Run `npm i --save react-native-ble-manager`. No manual linking is required because the library supports the React Native autolink feature. Minimum platforms are iOS 15.1 and Android API level 23. The full API reference lives on the documentation site linked from the README.

### Does the example app in the repository work with npm packages?

No. The README notes that the `react-native-ble-manager/example` directory is only included when you clone the repository, so importing it from `node_modules` will not work. The bundled example is meant for local development and for confirming that your device and BLE setup behave before writing your own code.

### How do I regenerate the native code from the specs?

A React Native project is needed to run codegen. For Android, run `npx expo prebuild --platform android` in the example folder and then `./gradlew generateCodegenArtifactsFromSchema` in the generated android directory. For iOS, codegen runs during the first build, and running `pod install` again forces it to rerun.

## Sources

- [innoveit/react-native-ble-manager on GitHub](https://github.com/innoveit/react-native-ble-manager)
- [License: Apache-2.0](https://github.com/innoveit/react-native-ble-manager/blob/master/LICENSE)
- [Project website](http://innoveit.github.io/react-native-ble-manager/)
- [README](https://github.com/innoveit/react-native-ble-manager/blob/master/README.md)
- [Releases](https://github.com/innoveit/react-native-ble-manager/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/innoveit-react-native-ble-manager