While building a React Native or Expo app, you may encounter an error saying `Unable to resolve module http` or `Unable to resolve module net` followed by a red screen showing `Could not get BatchedBridge, make sure your bundle is packaged correctly`. This happens when you import a package that depends on Node.js built-in modules like http, https, net, tls, stream, crypto, os, fs, or path. These modules exist in Node.js but do not exist in React Native because React Native runs on JavaScriptCore or Hermes, not Node.js.

The Error

1error: Unable to resolve module `http` from `node_modules/some-package/index.js`
2
3None of these files exist:
4  * http(.native|.ios|.android|.js|.jsx|.ts|.tsx)
5  * http/index(.native|.ios|.android|.js|.jsx|.ts|.tsx)
6
7error: Unable to resolve module `net` from `node_modules/some-package/lib/client.js`
8
9Could not get BatchedBridge, make sure your bundle is packaged correctly

You may also see this for other Node.js core modules: `Unable to resolve module https`, `Unable to resolve module tls`, `Unable to resolve module stream`, `Unable to resolve module crypto`, `Unable to resolve module fs`, `Unable to resolve module os`, `Unable to resolve module path`, `Unable to resolve module zlib`, `Unable to resolve module dns`, or `Unable to resolve module buffer`.

What Causes This Error

React Native uses Metro bundler which runs in a mobile JavaScript environment (Hermes or JavaScriptCore), not Node.js. Node.js has built-in modules like http, net, crypto, and fs that provide system-level functionality. These modules do not exist in React Native because mobile apps cannot open raw TCP sockets, read the file system directly, or create HTTP servers the way Node.js can. When you install a package that was built for Node.js (like a database driver, an SMTP client, or a server-side HTTP library), it tries to import these modules and Metro fails because they do not exist.

• Installed a Node.js server-side package in a React Native project
• Using a package that has separate browser and Node.js entry points but Metro picked the Node.js version
• Directly importing Node.js core modules like http, net, crypto, or fs
• A dependency deep in node_modules imports a Node.js module that the top-level package does not need
• Using a MongoDB, PostgreSQL, or MySQL client library built for Node.js instead of a REST API or mobile SDK
• Using a Node.js SMTP or email library directly in React Native
• Metro config missing browser field resolution that would pick the correct entry point

Fix 1: Use the Correct Package for React Native

The best fix is usually to not polyfill Node.js modules at all. Instead, replace the Node.js package with a React Native compatible alternative. Many packages that work in Node.js have React Native or browser equivalents that use fetch, XMLHttpRequest, or native modules instead of Node.js built-ins.

1# WRONG: Node.js packages that will fail in React Native
2npm install axios          # Works (uses XMLHttpRequest)
3npm install node-fetch     # FAILS (uses http module)
4npm install nodemailer     # FAILS (uses net, tls, dns)
5npm install mongoose       # FAILS (uses net, tls, dns)
6npm install pg             # FAILS (uses net, tls, crypto)
7npm install ws             # FAILS (uses http, net)
8npm install jsonwebtoken   # FAILS (uses crypto)
9
10# RIGHT: React Native compatible alternatives
11npm install axios                    # HTTP client (works in RN)
12npm install @react-native-firebase/firestore  # Database
13npm install @supabase/supabase-js    # Database + auth
14npm install expo-crypto              # Crypto operations
15npm install react-native-tcp-socket  # Raw TCP if needed
16npm install jwt-decode               # Decode JWTs (no crypto needed)

Common Replacements

• HTTP requests: Use axios or fetch (built into React Native) instead of node-fetch or got
• WebSockets: Use React Native built-in WebSocket API or socket.io-client instead of ws
• Database: Use REST APIs, Supabase client, Firebase SDK, or Expo SQLite instead of mongoose, pg, or mysql2
• Crypto: Use expo-crypto or react-native-crypto instead of Node.js crypto
• JWT: Use jwt-decode to read tokens client-side, verify tokens on your backend server instead
• File system: Use expo-file-system or react-native-fs instead of Node.js fs
• Email: Send emails through your backend API, not directly from the mobile app

Fix 2: Install Node.js Core Module Polyfills

If you must use a package that requires Node.js modules and there is no React Native alternative, you can install polyfills that provide browser-compatible implementations of Node.js built-in modules. This is a workaround, not the ideal solution. Polyfills add bundle size and may not implement every feature of the real Node.js module.

1npm install node-libs-react-native react-native-get-random-values

Import the polyfills at the very top of your app entry point, before any other imports.

1// index.js or App.tsx - MUST be the first import
2import 'react-native-get-random-values'; // Polyfills crypto.getRandomValues
3import 'node-libs-react-native/globals'; // Polyfills http, stream, buffer, etc.
4
5// Then your normal imports
6import { AppRegistry } from 'react-native';
7import App from './App';
8
9AppRegistry.registerComponent('main', () = App);

Fix 3: Configure Metro Resolver for Individual Polyfills

For more control, you can tell Metro to resolve specific Node.js modules to their polyfill packages individually. This is better than a blanket polyfill because you only include what you actually need, keeping your bundle smaller.

1npm install stream-browserify buffer events process readable-stream

1// metro.config.js
2const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
3
4const defaultC getDefaultConfig(__dirname);
5
6const c {
7  resolver: {
8    extraNodeModules: {
9      stream: require.resolve('stream-browserify'),
10      buffer: require.resolve('buffer/'),
11      events: require.resolve('events/'),
12      process: require.resolve('process/browser'),
13      http: require.resolve('stream-http'),
14      https: require.resolve('https-browserify'),
15      crypto: require.resolve('react-native-crypto'),
16      net: require.resolve('react-native-tcp-socket'),
17      tls: require.resolve('react-native-tcp-socket'),
18      os: require.resolve('os-browserify/browser'),
19      path: require.resolve('path-browserify'),
20      zlib: require.resolve('browserify-zlib'),
21      fs: require.resolve('react-native-level-fs'),
22    },
23  },
24};
25
26module.exports = mergeConfig(defaultConfig, config);

You do not need to polyfill every module. Only add entries for the modules that your specific dependency actually uses. Check the error message to see which module is missing and add just that one.

Expo Metro Config Version

1// metro.config.js (Expo)
2const { getDefaultConfig } = require('expo/metro-config');
3
4const c getDefaultConfig(__dirname);
5
6config.resolver.extraNodeModules = {
7  ...config.resolver.extraNodeModules,
8  stream: require.resolve('stream-browserify'),
9  buffer: require.resolve('buffer/'),
10  crypto: require.resolve('react-native-crypto'),
11  // Add only what you need
12};
13
14module.exports = config;

Fix 4: Create Empty Module Stubs

Sometimes a dependency imports a Node.js module but never actually calls it in the code path your app uses. For example, a package might conditionally require net only on the server side. In this case, you can create an empty stub file that Metro resolves to instead of the real module. This avoids installing a full polyfill for a module you never use.

1// shims/empty-module.js
2module.exports = {};

1// metro.config.js - point unused modules to the empty stub
2const path = require('path');
3
4const c {
5  resolver: {
6    extraNodeModules: {
7      net: path.resolve(__dirname, 'shims/empty-module.js'),
8      tls: path.resolve(__dirname, 'shims/empty-module.js'),
9      dns: path.resolve(__dirname, 'shims/empty-module.js'),
10      fs: path.resolve(__dirname, 'shims/empty-module.js'),
11    },
12  },
13};

Warning: if the dependency actually calls functions from the stubbed module at runtime, your app will crash with `undefined is not a function` or similar errors. Only use stubs for modules that are imported but never called in your code path.

Fix 5: Use the Browser Field in Package.json

Some packages provide both a Node.js and a browser entry point using the `browser` field in their package.json. Metro should pick the browser version automatically, but in some configurations it does not. You can force Metro to prefer the browser field.

1// metro.config.js
2const c {
3  resolver: {
4    resolverMainFields: ['react-native', 'browser', 'main'],
5  },
6};

Fix 6: Understanding the BatchedBridge Error

The `Could not get BatchedBridge` red screen is not the real error. It is a secondary error that appears because the JavaScript bundle failed to load. When Metro encounters an `Unable to resolve module` error during bundling, it produces a broken bundle. React Native tries to load this bundle, fails to initialize the JS runtime, and shows the BatchedBridge error. To find the real error, check your Metro terminal output. The actual `Unable to resolve module` error will be printed there before the BatchedBridge error appears on the device.

1# The real error is in the Metro terminal output, not on the device
2# Look for lines like:
3
4error: Unable to resolve module `net` from `node_modules/...`
5
6# The BatchedBridge error on the device is just saying
7# "the bundle failed to load" - fix the Metro error first

Quick Diagnosis Checklist

• Check Metro terminal output for the real Unable to resolve module error, not the BatchedBridge red screen
• Identify which package is importing the Node.js module from the error path
• Check if a React Native compatible alternative exists before adding polyfills
• If polyfilling: import polyfills at the very top of your entry file before all other imports
• Only polyfill the specific modules your dependency needs, not all Node.js modules
• Use empty stubs for modules that are imported but never called at runtime
• Set resolverMainFields to prefer browser entry points over Node.js entry points
• Clear Metro cache with --reset-cache after changing metro.config.js
• Check if the package has a react-native field in its package.json
• If using a database: connect through a REST API or SDK, not a direct Node.js driver

Common Packages That Cause This Error

1# Packages that import Node.js modules and their RN alternatives:
2
3# mongoose / mongodb driver → Use REST API or Firebase/Supabase SDK
4# pg (PostgreSQL) → Use REST API or Supabase client
5# mysql2 → Use REST API
6# nodemailer → Send emails via backend API endpoint
7# ws (WebSocket) → Use React Native WebSocket API or socket.io-client
8# jsonwebtoken → Use jwt-decode (decode only) + verify on backend
9# node-fetch → Use built-in fetch (global in RN)
10# bcrypt / bcryptjs → Hash passwords on backend, not in mobile app
11# sharp / jimp → Use expo-image-manipulator
12# puppeteer → Cannot run in mobile app
13# express / fastify → Cannot run server in mobile app

Final Working Metro Config

1// metro.config.js - selective polyfills example
2const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
3const path = require('path');
4
5const defaultC getDefaultConfig(__dirname);
6
7const emptyModule = path.resolve(__dirname, 'shims/empty-module.js');
8
9const c {
10  resolver: {
11    resolverMainFields: ['react-native', 'browser', 'main'],
12    extraNodeModules: {
13      // Polyfill modules you actually need
14      stream: require.resolve('stream-browserify'),
15      buffer: require.resolve('buffer/'),
16      events: require.resolve('events/'),
17      // Stub out modules you do not need
18      net: emptyModule,
19      tls: emptyModule,
20      dns: emptyModule,
21      fs: emptyModule,
22    },
23  },
24};
25
26module.exports = mergeConfig(defaultConfig, config);

Official-Style Error Explanation

The Unable to resolve module http, net, tls, crypto, or other Node.js built-in module errors occur in React Native because the Metro bundler runs in a mobile JavaScript environment (Hermes or JavaScriptCore) that does not include Node.js built-in modules. When a package designed for Node.js tries to import these modules, Metro cannot find them and the bundle fails. The subsequent Could not get BatchedBridge error is a secondary failure that appears because the broken bundle could not initialize the JavaScript runtime. The fix depends on the situation: replace the Node.js package with a React Native compatible alternative when possible, install polyfill packages that provide browser-compatible implementations of Node.js modules when a replacement does not exist, configure Metro extraNodeModules to map specific modules to their polyfills, or create empty module stubs for modules that are imported but never called at runtime. Always check the Metro terminal output for the real error, not the BatchedBridge red screen on the device.