A Practical Guide to Heatmaps in React Native Apps

React Native heatmaps show where users tap, swipe and long-press on each screen of your iOS and Android app, combined across many sessions. Web heatmap scripts can't read a React Native app, because it has no DOM. UXCam records gestures in its native SDKs and draws one heatmap per screen. So accurate heatmaps depend on tagging each screen yourself, for example inside React Navigation's useFocusEffect.
| Requirement | Why it matters | How to do it in React Native |
|---|---|---|
| Gesture capture | Taps and swipes happen in native views, not in a DOM | UXCam's native iOS and Android SDKs record them |
| Screen names | A heatmap is drawn per screen | Call RNUxcam.tagScreenName() when each screen gains focus |
| Clean names | IDs in names split one screen into thousands | Use "Product Details", not "Product Details - 12345" |
| Tabs and modals | Otherwise taps from several views land on one heatmap | Tag each tab and modal as its own screen |
| Enough sessions | Heatmaps combine many sessions | Let real traffic build up for a few days |
| Frustration signals | They show where taps don't work | Rage taps and UI freezes are logged automatically |
If you're reading this, you probably want to see how people use the screens of your React Native app. What do they tap, what do they ignore, and where do they get stuck? There's an even higher chance you're looking for a heatmap tool that actually works with React Native.
The good news: This guide explains how heatmaps work in React Native and why screen tagging decides whether they're accurate. It also shows you how to set them up with UXCam. UXCam's React Native SDK records your iOS and Android apps, including Expo apps built with a development build. The same UXCam account covers your website through the web SDK, so you can compare behavior in your app and on the web.
Why React Native needs a dedicated heatmap tool
React Native lets you write an app once in JavaScript and ship it to iOS and Android as native UI. That's exactly why web heatmap libraries don't work with it. They listen for clicks in a browser's Document Object Model, and a React Native app has no DOM. Your components become native views, and iOS and Android handle touches before your JavaScript sees them.
Gestures also differ by platform. Think of swipe-back on iOS, the hardware back button on Android, or a long press that opens a menu on one platform and does nothing on the other. One codebase hides a lot of platform-specific behavior. A tool that only counts clicks can't tell these cases apart.
One detail matters more than any other for heatmaps. A heatmap is drawn per screen, so the tool has to know which screen the user was on when they tapped. Native apps expose that through view controllers and activities. In React Native, screen changes happen inside JavaScript libraries such as React Navigation or Expo Router, which don't fire those native events.
So a React Native heatmap tool needs two things. It needs an SDK that records gestures inside the app. And it needs a reliable way to learn which screen is showing.
How heatmaps work in React Native
UXCam's React Native SDK is the react-native-ux-cam package. It's a thin JavaScript layer over UXCam's native iOS and Android SDKs. While a session records, it captures the screen video and every gesture, each with its position and timestamp. After upload, UXCam groups those gestures by screen name and draws a heatmap for each screen across the sessions you select.
Capturing taps, swipes and other gestures
Taps, swipes and long presses are recorded where they happened. The heatmap therefore shows hotspots on the real layout of your screen, not an abstract list of events. The gestures live inside the session, so the same data powers both the heatmap and the replay. Any hotspot is a few clicks away from the sessions that produced it.
Attaching every gesture to the right screen
Each gesture is attached to the screen name that was active at that moment. In React Native, you set that name yourself with RNUxcam.tagScreenName(), usually when a screen gains focus. Get it right and every tap lands on the right heatmap. Get it wrong and taps from several screens pile up on one heatmap that matches none of them.
Rage taps and UI freezes
Two frustration signals come without any code. A rage tap is when a user taps the same spot again and again because nothing seems to happen. A UI freeze is when the main thread stops responding for two seconds or more. UXCam logs both as events on the session, so you can filter for them and open the heatmap of the screen where they cluster.
Performance across devices
Gesture capture runs inside UXCam's native SDKs, not in your JavaScript code. A session uploads when the app moves to the background. Heatmaps are built in the dashboard from data the SDK already records, so they add no extra work on the device. To learn how the SDK keeps its footprint small, read why UXCam has one of the best performing SDKs.
How to set up UXCam heatmaps in React Native
Setting up heatmaps is the same as setting up UXCam itself. Once sessions are recording and screens are tagged, heatmaps fill in on their own. These steps follow UXCam's React Native quick start.
Create an account and get your app key: Sign up for UXCam and copy your app key from the dashboard. Use a separate key for development builds, so test sessions stay out of your production heatmaps.
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+. Since version 6.0.0, it also supports React Native's New Architecture.
Start 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. Set enableAutomaticScreenNameTagging to false, because React Native screens need manual tags. The docs also recommend setting enableImprovedScreenCapture to true.
Tag your screens: Call RNUxcam.tagScreenName() when each screen gains focus. This step is what makes heatmaps accurate, so it gets its own section below.
Use a development build if you're on Expo: Expo Go can't load UXCam's native modules. Build the app as a development build or with EAS Build, as UXCam's Expo installation guide describes. If RNUxcam comes back null or undefined, the app is still running in Expo Go.
Check your first session: 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. It should appear in your dashboard within about a minute.
Read 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 they won't appear in Metro or your editor's terminal.
Give heatmaps time to fill: A heatmap aggregates many sessions, so one test session gives you a replay, not a heatmap. Let real traffic build up for a few days, and check your screen list in the meantime.
The full React Native integration guide lists every configuration option. That includes privacy rules you can apply at startup.
Why screen tagging decides heatmap accuracy
UXCam's screen tagging guide for React Native is clear on this point. Automatic screen tagging isn't reliable in React Native, because JavaScript screens don't trigger the native lifecycle events it depends on. So turn automatic tagging off and tag every screen yourself. Use human-readable names such as Home Dashboard or Checkout Payment, not component names.
With React Navigation, the simplest pattern is to tag inside useFocusEffect, wrapped in useCallback, in each screen. The effect runs whenever the screen comes into focus, including when the user navigates back to it. That's exactly when a new screen should start on the timeline. Many teams wrap this in a small useScreenTracking hook, so every screen is tagged the same way.
Prefer to tag in one place? UXCam's React Navigation guide also shows a global handler on the NavigationContainer. It reads the current route name whenever the navigation state changes. React Navigation describes the same approach in its guide to screen tracking.
Other navigation setups work too. With Expo Router, tag from your root layout using the current route segments, and leave route groups in parentheses out of the name. Apps on Wix's React Native Navigation tag screens in componentDidAppear.
A few habits keep heatmaps readable. Tag each tab of a tab navigator separately, such as Home Tab and Search Tab, or taps from every tab will merge into one heatmap. Tag modals when they open, so taps inside a modal don't land on the screen behind it. If a screen's name depends on data that loads later, tag it once the data has arrived.
Keep IDs out of screen names, too. Product Details - Electronics is a useful screen name. Product Details - 12345 creates thousands of screens, each with a handful of taps.
Before you rely on a heatmap, check the screen list in the dashboard. Each screen should show up once per visit with a duration above zero seconds, and no Unknown or component class names should remain. A 0s screen usually means two tags fired in the same frame, often from a re-render or from automatic tagging that's still on. Tags less than 300 milliseconds apart also collapse, so debounce your tag calls if users switch tabs quickly.
Common React Native use cases for heatmaps
Once screens are tagged, heatmaps answer questions that event counts can't. These are the situations where React Native teams get the most out of them.
Fixing misaligned tap zones: Components that resize with dynamic content can leave a button's touch area smaller than it looks. An invisible view can also cover it. Taps clustering just outside the target are the first clue that a hitSlop, padding or overlay needs fixing.
Validating onboarding flows: Multi-step onboarding built with a pager or a stack of screens shows where attention goes on each step. If users tap the illustration instead of the Continue button, the heatmap for that step makes it obvious.
Improving gesture-heavy components: Carousels, swipe-to-dismiss cards and bottom sheets depend on gestures users have to discover. Filter a heatmap to swipes to see whether people find the gesture at all. The replays behind it show whether it responds as expected on both platforms.
Diagnosing device-specific UI issues: Filter a heatmap by device, OS or app version to check a layout on small phones and tablets alike. Rage taps that only appear on one Android version are a strong hint that a component renders differently there.
Checking a redesign: Compare the same screen over two date ranges, before and after a release. You'll see whether the new layout moved attention where you intended.
UXCam heatmaps for React Native
UXCam builds a touch heatmap for every tagged screen of your React Native app. You can see at a glance which elements attract taps and which ones users skip. Hotspots are drawn on a capture of the screen itself. That makes it easy to spot a button nobody finds, or a decorative element people keep trying to tap.
Filters turn one heatmap into many. Gesture filters isolate a single interaction type, such as taps or swipes, so a busy screen becomes readable. Property filters narrow the heatmap to the users or sessions you care about, such as a device model, an app version or a subscription plan you send yourself. Date filters let you compare periods and see how behavior changed after a release.
Next to the heatmap, screen statistics show how often each screen is visited and how long people stay. And every hotspot links back to real sessions. Say a heatmap shows rage taps on a coupon field. You can jump straight to the session replays where they happened and see what the user was trying to do.
Let Tara point you to the screens worth a heatmap
In an app with dozens of screens, the hard part is knowing which heatmap to open. Tara, UXCam's AI analyst, works from the data UXCam captures automatically. It surfaces what changed and where users struggle without waiting for you to ask. A typical example is a jump in rage taps on a checkout screen after the latest release.
From there, the heatmap is your evidence. Open it for the screen Tara flagged, see where the frustration concentrates, and watch the sessions behind the hotspot. After you ship a fix, compare the heatmap before and after the release, and measure the result in your funnels and dashboards.
If your team works in AI assistants, UXCam's MCP server brings the same data into tools like Claude or Cursor. You can ask about a screen without leaving your editor.
Connect heatmaps with session replay, funnels and events
A heatmap shows where users tap. The rest of UXCam explains why, and how much it matters. Session replay shows the actions around a hotspot in order. Funnels show which step of a flow loses the most users, so you know which heatmap to study first. User journeys show the paths people take between screens, including ones you didn't design for.
The events and user data you send make heatmaps sharper. Log actions such as paywall_viewed or coupon_applied with RNUxcam.logEvent(), with up to 20 properties each, as the events guide describes. After login, RNUxcam.setUserIdentity() swaps UXCam's random alias for your own user ID. RNUxcam.setUserProperty() then adds attributes such as plan or role, as the user properties guide explains.
With that data in place, heatmaps get more specific. You can compare a pricing screen for free and paying users, or look only at sessions that reached checkout.
Privacy: what heatmaps and replays show
Heatmaps come from session recordings, so decide what those recordings may show before you ship. In React Native, UXCam automatically masks password fields that use secureTextEntry, and standard credit card inputs. Everything else on screen, including names, addresses and messages, appears in the replay until you mask it. Masking happens on the device before upload, so hidden content never reaches UXCam's servers.
The quickest way to set rules is in the dashboard, under Settings, Video Recording Privacy. There you can record, occlude or blur all screens or individual ones, without shipping code. In code, UXCam's occlusion guide recommends defining rules in the occlusions list of your startup configuration. Use an overlay or a blur for whole screens such as Login or Payment Details, and hide all text fields on the screens that need it.
For single components, pass a view's ref to RNUxcam.occludeSensitiveView(). You can also wrap a region in the package's UXCamOccludedView component.
Overlay and blur rules have a hideGestures setting that matters for heatmaps. Set it to true to keep taps on that screen out of the recording. You want that on a PIN pad, where tap positions alone could reveal a code. Leave it off where content is hidden but the interaction pattern is still worth studying.
WebViews need one extra decision. For payment and health flows, occlude the whole WebView. Masking individual HTML elements can briefly drop while the WebView loads a new page.
Examples of React Native apps that use UXCam's heatmaps
Hundreds of React Native apps use UXCam's heatmaps. Here are two of them.
Zé Delivery
Zé Delivery is a leading delivery app in Latin America with more than 10 million users. It started as an independent startup inside Ambev, the world's biggest brewery and one of Brazil's biggest companies. The goal was simple: deliver cold beer whenever and wherever people want it.
With UXCam I can really see what our customers are doing and understand better how they are doing. It helps me to create new tasks to my team's backlog and add a way for everybody to see the evidence of some problem.
- Maria Fernanda Lopes, Product Designer
Inspire Fitness
Inspire Fitness combines home fitness equipment with live and on-demand classes. Its React Native app is growing quickly, with new instructors and training programs added all the time. The team used UXCam to reduce total app crashes by 40% and rage taps by 56%.
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
Optimize user experience with heatmaps in React Native apps
Heatmaps show React Native teams how people use each screen: where they tap, what they miss and where they get frustrated. In React Native, the quality of that view depends on screen tagging. So turn automatic tagging off, tag screens on focus, and check the screen list before you draw conclusions.
With screens tagged and privacy rules in place, UXCam does the rest. Tara points you to the screens where something changed, and heatmaps show where the problem sits. Session replays show why it happens, and funnels and dashboards show whether your fix worked. To see your own React Native app this way, get started with UXCam.
FAQ
How do heatmaps technically work in React Native?
UXCam's React Native SDK records each gesture, such as a tap, swipe or long press, with its position and time. It attaches every gesture to the screen name that was active at that moment. The dashboard then combines gestures from all sessions on that screen into a heatmap. React Native screens are JavaScript components, so you tag them yourself with RNUxcam.tagScreenName().
Why do my React Native heatmaps merge different screens?
Usually because screens aren't tagged. Automatic screen tagging can't see React Navigation or Expo Router screen changes, so taps from several screens end up under one name. Set enableAutomaticScreenNameTagging to false and call RNUxcam.tagScreenName() in useFocusEffect for each screen. Tag every tab and modal separately, too.
Why can’t I use a web heatmap tool for React Native apps?
Web heatmap tools read clicks from a browser's DOM. A React Native app renders native iOS and Android views, so there is no DOM to read. Touch gestures such as swipes never reach a web script either. You need an SDK that records gestures inside the app, such as UXCam's react-native-ux-cam package. For your website, UXCam's web SDK provides heatmaps in the same account.
Does UXCam support Expo and the bare workflow?
Yes. Bare React Native projects install react-native-ux-cam and run pod install for iOS. Expo apps need a development build or EAS Build, because Expo Go can't load UXCam's native modules. If RNUxcam is null at runtime, the app is running in Expo Go. UXCam supports React Native 0.68+ and Expo SDK 47+.
Do heatmaps slow down the app?
No. Heatmaps are built in the UXCam dashboard from the gestures the SDK already records, so they add no extra work on the device. Capture runs in UXCam's native iOS and Android SDKs. Sessions upload when the app moves to the background.
What gestures are supported?
Heatmaps show taps, swipes and long presses where they happened on each screen. You can filter a heatmap to one gesture type. Rage taps, when a user taps the same spot again and again, are detected automatically. UXCam logs them as events, so you can find the screens where they cluster.
Related articles:
Session replay for React Native apps
React Native analytics: an implementation guide
Mobile app analytics for React Native apps
Best tools and techniques for React Native crash reporting
React Native performance monitoring: best tools and techniques
Related articles
News & Trends
Black Friday benchmarks for shopping apps 2026: traffic, checkout and the peak day
Black Friday is the busiest day of the season for only one in four shopping apps. UXCam analysed 355 million shopping app sessions from Black Friday 2025. Traffic starts rising 11 days early, the typical app gains 33% over the weekend, and the busiest day runs at 2.3x a normal...

Growth Marketing Manager
Conversion Analysis
Conversion Rate Optimization Audit: A 6-Step Guide for 2026
A step-by-step guide to running a conversion rate optimization audit: the warning signs, the six steps, and the data and tools to...

Product Analytics Expert
Conversion Analysis
Conversion Funnel Analysis: A Complete Guide for 2026
Conversion funnel analysis is how product teams find where users drop off in critical flows like signup, checkout, and activation, and fix the specific...

Founder & CEO | UXCam


