React Native Mobile App Analytics Tool: UXCam

If you're reading this, you're probably trying to figure out what people actually do in your React Native app. Which features do they use, where do they drop out of key flows, and why did the last release move your numbers? There's an even higher chance you're looking for an analytics tool that understands React Native, one that works without you instrumenting every button first.

The good news: This guide explains what UXCam captures in a React Native app on its own and what you add with a few lines of code. It shows how Tara, funnels, heatmaps and session replay turn that data into answers, and it covers setup, Expo and privacy. For a complete tracking plan, from event names to duplicate events on re-renders, read our React Native analytics implementation guide. UXCam covers mobile apps and the web, so your website can live in the same UXCam account.

What a React Native analytics tool needs to handle

React Native apps are JavaScript applications that render native iOS and Android views. That split makes them fast to build. It also trips up analytics tools designed for one world or the other.

Web analytics scripts look for a DOM that doesn't exist. Native SDKs look for view controllers and activities, but your screens are React components. Navigation happens inside libraries such as React Navigation or Expo Router, not in the operating system.

So a good React Native analytics tool has three jobs. It captures what users see and touch on both platforms from a single integration. It knows reliably which screen is showing, because every screen-level report depends on it. And it separates the two kinds of failure your app can have: native crashes in iOS or Android code, and JavaScript errors the operating system never sees.

There are practical needs too. Many teams build with Expo, so the tool has to work with development builds and EAS Build. Text inputs carry personal data, so masking has to happen on the device. And because one codebase ships to two platforms, you want to compare iOS and Android side by side rather than assume they match.

What UXCam captures automatically

UXCam's React Native SDK is the react-native-ux-cam package, a wrapper around UXCam's native iOS and Android SDKs. Once it's initialized, every session is recorded without extra instrumentation. That includes the screen video and every tap and swipe with its position and timing. It also includes the session's context, such as device, operating system, app version and location.

That's what UXCam means by autocapture. The raw behavior is there from the first session, whether or not you thought to track it.

Frustration and stability signals come without code too. Rage taps are repeated taps on the same spot when nothing seems to happen. UI freezes are moments when the main thread stops responding for two seconds or more. UXCam logs both as events on the session, and it captures native crashes and ANRs with their stack traces, linked to the replay.

Because behavior is already captured, you don't need to define every event up front. With smart events, you define an event in the dashboard from interactions UXCam has already recorded. You can then analyze it over past data instead of waiting for the next release. The same captured data lets Tara, UXCam's AI analyst, work on a new app from day one.

What you add: screens, events and users

Some things only your code knows, and they're worth adding early. In React Native, the most important one is screen names. UXCam's screen tagging guide explains why: automatic tagging isn't reliable, because JavaScript screens don't trigger the native lifecycle events it relies on.

So set enableAutomaticScreenNameTagging to false and tag each screen yourself. Call RNUxcam.tagScreenName() when a screen gains focus, typically inside useFocusEffect with React Navigation. Screen names drive heatmaps, screen statistics, funnels and journeys. A clean screen list is the foundation of everything else.

Custom events capture the business moments that matter to you, such as signup_completed, paywall_viewed or order_placed. Log them with RNUxcam.logEvent(), adding up to 20 properties with string, number or boolean values. Names and keys are case sensitive, so agree on a convention such as snake_case. Keep dynamic values like IDs in properties, not in the event name, as the events guide recommends.

User identity ties sessions to real accounts. By default, UXCam gives each user a random alias based on the install. Call RNUxcam.setUserIdentity() as soon as someone logs in to replace it with your own user ID.

From there, user properties describe who the user is. RNUxcam.setUserProperty() adds attributes such as plan, role or acquisition source, up to 100 property keys per app. Session properties describe a single session, such as an A/B test group or a QA flag. UXCam recommends internal IDs over emails or phone numbers, as the user properties guide explains.

JavaScript errors are the one gap to plan for. The React Native runtime handles them, not the native layer UXCam hooks into, so they don't show up as crashes. The React Native SDK also has no handled-exception API.

UXCam's crash guide offers a simple workaround. Wrap ErrorUtils.setGlobalHandler and log each error as a js_error event with RNUxcam.logEvent(), then pass it on to the previous handler. The same call works in an error boundary's componentDidCatch, and every JavaScript error lands on the session timeline next to the replay.

How UXCam turns React Native data into answers

Collecting data is the easy part. What matters is how fast it tells you what to fix or build next. UXCam finds those answers proactively, and you check them against real sessions.

Tara finds what changed before you ask

Tara, UXCam's AI analyst, works from the data UXCam captures automatically. It surfaces what changed and where users struggle, such as a drop in checkout conversion after a release. You don't have to know which report to open first.

You can also ask Tara questions in plain language and have it build a funnel or a dashboard for you. And UXCam's MCP server brings the same data into AI assistants such as Claude, ChatGPT or Cursor.

Funnels show where users drop off

Funnel analytics measure how many users get through a flow such as onboarding, signup or checkout. They also show where the rest leave. Every step links to sessions, so you can go from a drop-off at the payment step straight to the sessions where users left.

Retention shows who comes back

Retention analytics show how many users return after their first session. Cohorts let you compare groups, such as users who finished onboarding and users who skipped it. That's how you find the early behaviors that predict whether someone sticks around.

Journeys, heatmaps and session replay show why

User journeys map the paths people take between screens, including loops and dead ends you didn't design. Heatmaps show where users tap on each screen and what they ignore. Session replay shows a whole session in order, with screens, gestures, events and issues on one timeline. Together, they turn a number on a chart into something you can see.

Issue analytics keep stability in view

Issue analytics group crashes, ANRs and UI freezes by type. They show how many users and sessions each issue affects, and they link every occurrence to its replay. Developers see the steps that led to a crash instead of rebuilding them from a stack trace.

Dashboards keep the team aligned

Dashboards put the metrics your team cares about in one place, from daily active users to the conversion of a single flow. They update as new sessions arrive. Product, design, engineering and support look at the same numbers and can open the same sessions.

How to set up UXCam in a React Native app

Setup takes a few minutes and follows UXCam's React Native quick start.

1. Create an account and get your app key: Sign up for UXCam and copy your app key from the dashboard. Create a second key for development builds, so test sessions stay out of your production data.

2. Install the package: Run npm install react-native-ux-cam or yarn add react-native-ux-cam, then cd ios && pod install. UXCam supports React Native 0.68+, Expo SDK 47+, iOS 12.0+ and Android minSdkVersion 21+. The package has supported React Native's New Architecture since version 6.0.0.

3. Initialize UXCam once: In a useEffect in your root App component, turn on video recording with RNUxcam.optIntoVideoRecording(). Then start UXCam with RNUxcam.startWithConfiguration() and your userAppKey. In the same configuration, set enableAutomaticScreenNameTagging to false and enableImprovedScreenCapture to true.

4. Tag your screens: Add RNUxcam.tagScreenName() to each screen, as described above. Tag each tab of a tab navigator separately, tag modals when they open, and keep IDs out of screen names.

5. Add your first events and user identity: Start with a handful of events around your most important flow. Call setUserIdentity() after login.

6. Verify the integration: Run the app on a device or simulator and move through three or four screens for about 30 seconds. Then send the app to the background, which ends the session and starts the upload. The session should appear in your dashboard within about a minute.

7. Check the native logs if it doesn't: Set enableIntegrationLogging to true in debug builds. Xcode's console and Android Studio's Logcat then show "Verification successful" and "Session uploaded". These logs are native, so you won't see them in Metro.

Stuck? The troubleshooting guide covers the common causes. The full integration guide documents every configuration option.

Using UXCam with Expo

UXCam works with Expo apps, with one condition. Expo Go can't load UXCam's native modules, so you need a development build or EAS Build. In practice, you run eas build:configure, build a development profile for iOS or Android, and start the app with npx expo start --dev-client. UXCam's Expo installation guide walks through each step.

The most common Expo issue has a simple cause. If RNUxcam is null or undefined at runtime, the app is running in Expo Go, not in your development build. If a build fails because of a missing native module, run npx expo prebuild and rebuild.

Screen names work the same way in Expo apps. With Expo Router, tag screens from the root layout using the current route segments, and leave route groups in parentheses out of the name.

Privacy and consent in React Native

Session recordings are only useful if you can trust what's in them. In React Native, UXCam automatically masks password fields that use secureTextEntry, and standard credit card inputs. Everything else on screen appears in recordings until you mask it. So plan masking for screens with personal data before you ship.

You can set rules without code in the dashboard, under Settings, Video Recording Privacy. There you choose to record, occlude or blur all screens or specific ones. In code, UXCam's occlusion guide recommends defining rules in the occlusions list of your startup configuration. Use overlays or blurs for whole screens, and hide all text fields on the screens that need it.

Single components can be hidden too. Pass a ref to RNUxcam.occludeSensitiveView(), or wrap the component in UXCamOccludedView. Masking happens on the device before upload, so masked content never reaches UXCam's servers. For WebViews that show payment or health data, occlude the entire WebView rather than individual HTML elements.

Consent is handled at runtime. UXCam records by default. RNUxcam.optOutOverall() stops and deletes the current session and turns recording off for that user until optInOverall() is called.

The setting resets when someone reinstalls the app. So store the user's choice yourself and apply it at startup, or start UXCam only after consent. The opt-in and opt-out guide has the details.

Keep your React Native analytics clean

Analytics are only as good as the data behind them, and React Native development creates a lot of noise. Use separate UXCam app keys for development and production. Keep them in environment variables, not in your repository, and turn on integration logging only in debug builds. If testers use production builds, a session property such as is_qa makes them easy to filter out.

Already running another crash reporter, such as Firebase Crashlytics? Decide which tool owns crash reporting. UXCam's docs warn that two crash handlers can conflict, so turn one off at startup. For UXCam, that means setting enableCrashHandling to false.

You can still connect the two tools. RNUxcam.urlForCurrentSession() returns a link to the current session. Attach it to a crash report or a support ticket, and anyone can jump to the replay.

Performance is the other common worry. Capture runs inside UXCam's native SDKs, and sessions upload when the app goes to the background. You can also pause screen recording on specific screens with pauseScreenRecording(). Our post on why UXCam has one of the best performing SDKs explains how the SDK keeps its footprint small.

Who uses UXCam for React Native analytics

Hundreds of React Native teams use UXCam, from delivery apps to fitness platforms. Inspire Fitness combines home fitness equipment with live and on-demand classes. In its React Native app, the team used UXCam's session replays and issue analytics to reduce total app crashes by 40% and rage taps by 56%. The product team also uses UXCam to see which content and instructors drive the most engagement.

We wanted to make data-driven decisions on what content to push out next and evaluate how our instructors are doing. With UXCam, we get a holistic picture of the top-performing content within the app and the instructors that drive the highest user engagement.

- Neil Jain, Product Manager, Inspire Fitness

Get started with UXCam for React Native

React Native lets you ship one codebase to two platforms, and your analytics should work the same way. UXCam records every session of your iOS and Android app from a single integration. It captures behavior without tagging every button. You add the screen names, events and user properties that only your code knows.

From there, Tara surfaces what changed and where users struggle. Funnels and retention measure the impact, and heatmaps and session replays show the reason behind every number. To see your own app this way, get started with UXCam. Then use the React Native analytics implementation guide to plan your tracking.

Related articles:

React Native analytics: an implementation guide

Heatmaps in React Native apps

Session replay for React Native apps

React Native crash reporting: best tools and techniques

How to set up the React Native SDK

Best mobile app analytics tools