react-native-nfc-manager v4 for React Native NFC Apps

What react-native-nfc-manager Solves

react-native-nfc-manager is a native React Native module for communicating with NFC tags from JavaScript and TypeScript application code. It is aimed at mobile applications that need to read NDEF data or interact with specific NFC technologies such as NFC-A, ISO-DEP, NFC-V, MIFARE, and FeliCa. The repository describes it as a module for both Android and iOS, and its source tree includes native `android/` and `ios/` directories alongside JavaScript and TypeScript code.

Version 4 is not a general-purpose web NFC implementation. It requires React Native 0.76 or later with the New Architecture, and the README explicitly requires an NFC-capable physical device for scan testing. That boundary matters for project selection. A team building a React Native application with existing native Android or iOS requirements can use the module, while a team relying on Expo Go cannot. Expo Go cannot load this native module, so Expo projects need a development build.

The library also separates broad technology requests from tag retrieval. An application can request a technology such as `Ndef`, then retrieve the discovered tag through the module API. The actual tag support still depends on the device and operating system, so the technology table is a compatibility guide rather than a guarantee for every phone.

How the v4 NFC Request Flow Works

The documented flow starts with `NfcManager.start()`, followed by `NfcManager.requestTechnology()` and `NfcManager.getTag()`. The request is initiated from a user action, which is important because the README's example is designed to avoid overlapping scans and to await cleanup before another request is allowed.

The example tracks whether the request was attempted. After `getTag()` resolves, it reads the NDEF records from the returned tag with optional chaining. If scanning fails, the error is caught and reported. Cleanup runs in a `finally` block. When `requestAttempted` is true, `cancelTechnologyRequest()` is called before the scanning guard is reset. This is more deliberate than simply setting a boolean after a failure, because a rejected or interrupted native request can otherwise leave application state ambiguous.

The repository layout shows the boundary between package code and platform integrations. `src/` contains the module implementation exposed through the package entry point, `index.d.ts` contains public type declarations, `android/` and `ios/` contain native project integration, and `app.plugin.js` supports Expo configuration. The package publishes `dist`, `src`, `ndef-lib`, native directories, the podspec, plugin files, and specification files. This indicates a native bridge package rather than a JavaScript-only NFC parser.

Technology identifiers differ by platform. NDEF, NFC-A, and ISO-DEP use the same categories in the table for both operating systems. NFC-V and MIFARE have separate platform-specific names, while FeliCa also differs. Application code that needs more than one supported tag family must account for these naming differences.

Installing react-native-nfc-manager v4

Install the current release through npm. The README says to pin the resolved version for reproducible installs, which is particularly relevant because the repository distinguishes stable v4 from the v3 legacy line.

npm install react-native-nfc-manager

After installation, React Native CLI projects need platform setup. The README states that iOS projects should run `pod install` and configure NFC capabilities and a usage description. Android uses autolinking, but NFC permissions and device support still need to be checked. The native project must be rebuilt after native dependencies or plugin options change.

For React Native CLI, the documented platform preparation is therefore a native build step rather than a JavaScript-only command. The README links separate iOS and Android guides for the exact capability and permission configuration. Those guides are the relevant source for project-specific native settings because the root README does not reproduce the full capability lists.

Using react-native-nfc-manager with Expo Development Builds

Expo Go cannot load this native module. An Expo project must add the package to the `plugins` array in `app.json`, install `expo-dev-client`, generate native projects with prebuild, and run the app on a device.

{
  "expo": {
    "plugins": ["react-native-nfc-manager"]
  }
}

The documented setup commands are:

npx expo install expo-dev-client
npx expo prebuild
npx expo run:ios --device
# Or: npx expo run:android --device
npx expo start --dev-client

Choose the iOS or Android `run` command for the target platform, then start the development client. The physical-device requirement applies to scan testing. Changing native dependencies or plugin options requires rebuilding the app, so an Expo configuration edit is not necessarily enough to update a running binary.

A First NDEF Read in React Native

The README's first-use example reads an NDEF tag and protects against overlapping scans. Call it from a user action such as a button press. The guard is application state, while `cancelTechnologyRequest()` handles the native request lifecycle.

import NfcManager, {NfcTech} from 'react-native-nfc-manager';

let scanning = false;

async function readNdef() {
  if (scanning) return;
  scanning = true;
  let requestAttempted = false;
  try {
    await NfcManager.start();
    requestAttempted = true;
    await NfcManager.requestTechnology(NfcTech.Ndef);
    const tag = await NfcManager.getTag();
    console.log('NDEF records', tag?.ndefMessage ?? []);
  } catch (error) {
    console.warn('NFC scan ended', error);
  } finally {
    try {
      if (requestAttempted) {
        await NfcManager.cancelTechnologyRequest();
      }
    } catch (cleanupError) {
      console.warn('NFC cleanup failed', cleanupError);
    } finally {
      scanning = false;
    }
  }
}

The function logs `tag?.ndefMessage`, or an empty array when that property is unavailable. The example does not define the user interface that invokes `readNdef`, and it does not specify how records should be parsed for a particular product. The complete React screen and session lifecycle are documented separately under `docs/guide/reading-ndef.md`.

Platform and Tag Compatibility Boundaries

The documented technology matrix gives NDEF, NFC-A, and ISO-DEP coverage on Android and iOS. The identifiers for the remaining families are platform-specific. NFC-V is `NfcV` on Android and `Iso15693IOS` on iOS. MIFARE uses `MifareClassic` and `MifareUltralight` on Android, while iOS uses `MifareIOS`. FeliCa is `NfcF` on Android and `FelicaIOS` on iOS.

This means the library's API surface is cross-platform, but the exact technology selection is not uniformly named. Code that presents one scan screen across both platforms may need a platform mapping. The README also says that actual tag support depends on the device and operating system. A tag family appearing in the table does not establish that every supported phone can read every tag.

The module is therefore a poor fit for workflows that require guaranteed tag behavior across an uncontrolled device fleet without checking hardware and OS compatibility. It is more appropriate when the application can define its target devices and test the relevant tag technologies on physical hardware.

Version 4 Migration and Maintenance Cost

Version 4 is the current stable npm release, while version 3 is the legacy line for existing v3 or Legacy Architecture applications. The README directs v4 users to `docs/MIGRATING_V3_TO_V4.md` when upgrading an existing app. That separation is a real adoption constraint: v4 is not presented as a drop-in line for applications that still depend on the Legacy Architecture.

The repository's most recent listed release is `v4.0.0` on 2026-10-09, following beta releases `v4.0.0-beta.11` and `v4.0.0-beta.10`. The repository is not archived, and its last push was on 2026-10-09. The available history therefore shows current release activity around v4, but the repository still requires application teams to choose a version line deliberately and read the migration document before changing an existing installation.

The package uses the MIT license. That is the repository's stated licensing information, and it is relevant when reviewing distribution terms for an application. The README does not document a rollback procedure, a compatibility promise for every React Native release, or a detailed upgrade policy beyond the version split and migration link, so those points require verification in the relevant project documentation.

Why react-native-nfc-manager Differs from a JavaScript Tag Parser

A practical alternative is a JavaScript-only NDEF decoder used after data has already reached the application. That approach differs in mechanism: it can parse records in memory, but it does not provide the native device discovery and technology-request lifecycle provided by react-native-nfc-manager. For a web page or an application that receives tag data through another channel, a parser may be sufficient and avoids native setup.

For a React Native app that must ask the operating system to discover a nearby tag, the distinction matters. This repository includes native Android and iOS directories and requires a development build or native rebuild. A decoder cannot replace the permission, capability, device-support, and user-interaction requirements of a real NFC scan.

The choice should therefore follow the required interaction. Use a parser when the payload is already available and only record interpretation is needed. Use react-native-nfc-manager when the application must control native NFC discovery on Android or iOS and can support its React Native architecture and physical-device requirements.

Editorial conclusion

Adopt version 4 for a new React Native app that needs native NFC access and can meet its architecture and device requirements. Do not choose it for Expo Go, Legacy Architecture applications, or NFC emulation on unsupported hardware. Verify the target device, operating system, required technology, native capabilities, and migration notes before upgrading an existing app.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. revtel/react-native-nfc-manager on GitHub