# react-native-watch-connectivity talks to a native watch app from React Native

> react-native-watch-connectivity is a React Native bridge to Apple's WatchConnectivity framework, letting a React Native iOS app send messages to a watch app and read the reachability, pairing and installation state. It does not let you write the watch app itself, which must be Objective-C or Swift, and it needs React Native 0.76 with iOS 13.4.

**watch-connectivity/react-native-watch-connectivity** — Enable communication between apple watch app and react native

- Repository: https://github.com/watch-connectivity/react-native-watch-connectivity
- Website: http://mtford.co.uk/react-native-watch-connectivity/
- Stars: 786 · Forks: 98
- Language: TypeScript
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/watch-connectivity-react-native-watch-connectivity

## A bridge to the watch, not a watch app framework

react-native-watch-connectivity lets a React Native iOS app talk to an Apple Watch app over Apple's WatchConnectivity framework.

The limitation is stated in the first note of the README, and it decides who this library is for. This library does not allow you to write your Apple Watch apps in React Native, but rather allows your RN iOS app to communicate with a watch app written in Obj-C or Swift.

That is a narrower scope than the name might suggest, and it is a sensible one. Watch apps are small, mostly Swift, and often need to run with tight memory and energy limits; the team writing them may well be a different team, or a different skill set, from the React Native app that talks to them. This library covers the phone side of that boundary.

The project is maintained under the watch-connectivity organisation, with the package published to npm as react-native-watch-connectivity and documentation hosted at watch-connectivity.github.io. The author is Michael Ford, and the licence is MIT.

The requirements are a React Native 0.76 or later and iOS 13.4 or later. Those are the floors for the native side, since WatchConnectivity itself is an iOS and watchOS framework, and the React Native floor reflects the newer bridge and autolinking behaviour.

The last push was on 2026-07-03, the repository is not archived, and it publishes no GitHub releases, so the npm version, currently 2.0.0, is the handle to depend on.

## One function to send, three hooks to observe

The API is small, and the shape of it is what a React developer would expect.

```tsx
import {
  sendMessage,
  useReachability,
  usePaired,
  useInstalled,
} from 'react-native-watch-connectivity';

function App() {
  const reachable = useReachability();
  const paired = usePaired();
  const installed = useInstalled();

  const onPress = () => {
    sendMessage({ text: 'Hello from React Native!' }, (reply) => {
      console.log('Watch replied:', reply);
    });
  };

  return (
    // ...
  );
}
```

The three hooks correspond to three distinct facts about the connection, and keeping them separate is the useful part of the design. useReachability tells you whether the paired watch is currently reachable, which is not the same question as whether it is installed or paired. usePaired tells you whether a watch is paired with this phone at all. useInstalled tells you whether the watch app is actually present on the paired watch. A phone app that only asks one of those questions gets the wrong behaviour in the cases where they differ, for instance when the user has paired a watch that does not have your app installed.

sendMessage takes a payload and an optional reply callback. The callback form in the example is the shape that makes the library useful: the watch replies, and the reply arrives in JavaScript, so a round trip between the phone and the watch looks like a normal asynchronous call rather than a message subscription.

The package is written in TypeScript, and the metadata points the types entry at a generated declaration file, so a React Native project with types enabled gets the call signatures without extra work.

## Installing the package and the CocoaPods dependency

Installation is a package manager line and a pod install.

```bash
npm install react-native-watch-connectivity
# or
yarn add react-native-watch-connectivity
```

The iOS step follows, because the native side is a pod and the podspec is part of the package:

```bash
cd ios && pod install
```

The repository confirms this arrangement. There is a WatchConnectivity.podspec at the root, and the published files list includes the podspec along with the src, lib, android and ios directories and react-native.config.js, with the build directories explicitly excluded. The android directory is in the published package, but the framework being bridged is Apple's, so the usable path is the iOS one.

The package is built with bob, which is what the prepare script runs, and the package metadata exposes a source condition in the exports map so that a bundler can resolve the TypeScript source directly during development while consumers get the compiled module and the generated types.

The rest of the tooling is the usual React Native library set: a typecheck script that runs tsc, a lint script that runs eslint over the JavaScript and TypeScript sources, and a turbo.json alongside a yarn workspace setup with a .yarnrc.yml and a yarn.lock at the root.

## Running the example app and the watch workspace

The example application is the fastest way to see the whole path working, and the README gives the exact sequence.

```bash
git clone https://github.com/mtford90/react-native-watch-connectivity.git
cd react-native-watch-connectivity/example
yarn install
cd ios && pod install && cd ..
yarn ios
```

The watch side is a separate step, and it is a native one. To run the watch app you open example/ios/WatchConnectivityExample.xcworkspace in Xcode. The .xcworkspace rather than the .xcodeproj matters, because a workspace is what CocoaPods produces and it is what includes the pod targets.

That sequence is the clearest statement of the project's shape. The phone app runs from the example through Metro and the React Native CLI, the watch app is built and launched from Xcode as a native target, and the two meet over WatchConnectivity. There is no single command that runs both halves, because one of the halves is a native watchOS app.

The example directory itself is a full React Native project rather than a folder of snippets, with its own metro.config.js, babel.config.js, jest.config.js, react-native.config.js, app.json, a Gemfile, an ios directory and an android directory, so the watch target lives inside the same repository as the phone app.

There is also an Expo note, and it is a qualified one. The library has been successfully used in Expo apps, with the parenthetical that this means the Bare Workflow with EAS Build. The managed workflow is therefore not what is being described here.

## Where react-native-watch-connectivity is the wrong tool

The limits are mostly the ones the project states, plus a few that follow from the platform.

First, the watch app has to be native. If your goal is to write the watch experience in React Native as well, this library does not get you there and the README says so up front. The React Native side is the phone app, and that is the only side this project covers.

Second, it is an iOS-only integration in practice. The whole feature rests on Apple's WatchConnectivity framework, and the documentation, the podspec and the example workspace are all iOS. The package ships an android directory, but the README's own framing of the requirement, iOS 13.4 or later, and the fact that the whole example flow ends in an Xcode workspace, all point one way.

Third, there is no watchOS app to install. The library gives you a channel, not an application. If the work you need is on the watch side, you still write Swift, and the value here is only that the phone side of the conversation becomes easier.

Fourth, the API surface is small by design, and the parts it does not cover are the parts you will have to build. There is no documentation here of transferring files, of background transfers, or of the application context, so an app that needs to move a payload rather than send a message will be working past the documented surface.

Fifth, the release trail is thin. The package version is 2.0.0, the repository publishes no GitHub releases, and while the CHANGELOG.md at the root tracks changes, the version you install is whatever npm currently serves. For a bridge into a native framework, that is manageable, but it is a dependency to track rather than one to forget.

## Conclusion

React Native teams that already ship a native watch app and want the phone side of the conversation in JavaScript should use this library, because it exposes the WatchConnectivity session and its state as ordinary React hooks, which removes the bridge boilerplate from an app that has to react to a watch becoming reachable. It is the wrong tool if you want to build the watch app in React Native, which the README rules out, and it is the wrong tool for Android, where the platform has no equivalent of the framework. Before adopting, confirm your watch app is already native, check that your React Native and iOS versions meet the stated minimums, and read the docs site, which is where the API reference lives.

## FAQ

### Can I write an Apple Watch app with react-native-watch-connectivity?

No. The README states that this library does not allow you to write your Apple Watch apps in React Native, but rather allows your React Native iOS app to communicate with a watch app written in Objective-C or Swift.

### What do useReachability, usePaired and useInstalled each tell me?

They are three separate hooks: whether the watch is currently reachable, whether a watch is paired with the phone, and whether the watch app is installed on that paired watch. The Quick Start example uses all three, since the answers can differ.

### How do I install the library in a React Native project?

Run npm install react-native-watch-connectivity or yarn add react-native-watch-connectivity, then run cd ios && pod install. The requirements are React Native 0.76 or later and iOS 13.4 or later.

### Does react-native-watch-connectivity work with Expo?

It has been successfully used in Expo apps, with the README specifying the Bare Workflow with EAS Build. The managed workflow is not what the note describes.

## Sources

- [Issues](https://github.com/watch-connectivity/react-native-watch-connectivity/issues)
- [License: MIT](https://github.com/watch-connectivity/react-native-watch-connectivity/blob/master/LICENSE)
- [Project website](http://mtford.co.uk/react-native-watch-connectivity/)
- [README](https://github.com/watch-connectivity/react-native-watch-connectivity/blob/master/README.md)
- [watch-connectivity/react-native-watch-connectivity on GitHub](https://github.com/watch-connectivity/react-native-watch-connectivity)

---

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