AppKit for React Native enables seamless integration with multiple blockchain ecosystems, including EVM chains (like Ethereum, Polygon, etc.), Solana, and Bitcoin. It provides a unified API to manage wallet connections, interact with different chains, and build rich multi-chain applications.
At the core of AppKit is a centralized AppKit
instance that handles connection logic, manages various chain adapters, and provides data to your application via a React Context.
Don’t have a project ID?Head over to Reown Dashboard and create a new project now!
Installation
AppKit CLI
Get started quickly with our dedicated CLI that sets up a minimal AppKit configuration for you.
Run the command below and select React Native:
Add AppKit to your existing project
Installation is a two-step process:
- Install the core AppKit library.
- Install the specific chain adapters you need for your application.
Core Library
npx expo install @reown/appkit-react-native @react-native-async-storage/async-storage react-native-get-random-values react-native-svg @react-native-community/netinfo @walletconnect/react-native-compat react-native-safe-area-context expo-application
Create babel.config.js
For Expo SDK 53 and later, you need to create a babel.config.js
file in your project root to properly support the valtio library:module.exports = function (api) {
api.cache(true);
return {
presets: [["babel-preset-expo", { unstable_transformImportMeta: true }]],
};
};
This configuration enables the unstable_transformImportMeta
option which is required for valtio to work correctly with Expo 53+.
Chain Adapters
For React Native CLI projects, use npm install ...
or yarn add ...
.
Install the adapters for the chains you intend to support:
For EVM-compatible chains, you can choose between the Ethers.js-based adapter or the Wagmi-based adapter. You should install the one that best fits your project’s existing setup or preference.
This adapter uses Ethers.js for interacting with EVM chains.
npx expo install @reown/appkit-ethers-react-native
To initialize the Ethers adapter:
import { EthersAdapter } from '@reown/appkit-ethers-react-native';
const ethersAdapter = new EthersAdapter();
Implementation
Prerequisites
Before setting up AppKit, you need to wrap your app with SafeAreaProvider
from react-native-safe-area-context
. This is required for proper modal rendering and safe area handling.
Expo users: You can skip this step as it’s already handled internally by Expo.
import { SafeAreaProvider } from 'react-native-safe-area-context';
function App() {
return <SafeAreaProvider>{/* Your app content */}</SafeAreaProvider>;
}
For more detailed information about SafeAreaProvider
, check the official documentation.
1. Initialize AppKit
Create an instance of AppKit
. This is where you’ll configure your project ID (if using WalletConnect features) and define the chains your application will support, along with their respective adapters.
To ensure proper functioning with React Native, make sure import "@walletconnect/react-native-compat";
is the very first line in your configuration file (e.g., AppKitConfig.ts
), even before other imports. This import handles necessary polyfills.
// src/AppKitConfig.ts (or wherever you prefer to configure it)
import "@walletconnect/react-native-compat";
import { createAppKit, bitcoin, solana, type AppKitNetwork } from '@reown/appkit-react-native';
import { EthersAdapter } from '@reown/appkit-ethers-react-native';
import { SolanaAdapter } from '@reown/appkit-solana-react-native';
import { BitcoinAdapter } from '@reown/appkit-bitcoin-react-native';
// You can use 'viem/chains' or define your own chains using `AppKitNetwork` type. Check Options/networks for more detailed info
import { mainnet, polygon } from 'viem/chains';
const projectId = 'YOUR_PROJECT_ID'; // Obtain from https://dashboard.reown.com/
const ethersAdapter = new EthersAdapter();
const solanaAdapter = new SolanaAdapter();
const bitcoinAdapter = new BitcoinAdapter();
export const appKit = createAppKit({
projectId,
networks: [mainnet, polygon, solana, bitcoin],
defaultNetwork: mainnet, // Optional: set a default network
adapters: [ethersAdapter, solanaAdapter, bitcoinAdapter],
// Other AppKit options (e.g., metadata for your dApp)
metadata: {
name: 'My Awesome dApp',
description: 'My dApp description',
url: 'https://myapp.com',
icons: ['https://myapp.com/icon.png'],
redirect: {
native: "YOUR_APP_SCHEME://",
universal: "YOUR_APP_UNIVERSAL_LINK.com",
},
}
});
Default Features: AppKit comes with email and social login, swaps, and onramp features enabled by default. To disable any of these features, see the Options documentation for configuration details.
For data to persist across sessions, you need to provide a storage solution. The createAppKit
function accepts a storage
option that must conform to the Storage
interface.
The Storage
interface, which can be imported from @reown/appkit-react-native
, is defined as follows:
export interface Storage {
/**
* Returns all keys in storage.
*/
getKeys(): Promise<string[]>;
/**
* Returns all key-value entries in storage.
*/
getEntries<T = any>(): Promise<[string, T][]>;
/**
* Get an item from storage for a given key.
* @param key The key to retrieve.
*/
getItem<T = any>(key: string): Promise<T | undefined>;
/**
* Set an item in storage for a given key.
* @param key The key to set.
* @param value The value to set.
*/
setItem<T = any>(key: string, value: T): Promise<void>;
/**
* Remove an item from storage for a given key.
* @param key The key to remove.
*/
removeItem(key: string): Promise<void>;
}
For complete storage implementation examples, see the Storage Options documentation.
Update AppKit Configuration
Finally, import your custom storage and pass it to createAppKit
in your AppKitConfig.ts
. This example builds on the configuration from Initialize AppKit:
// src/AppKitConfig.ts (or wherever you prefer to configure it)
import "@walletconnect/react-native-compat";
import { createAppKit, bitcoin, solana, type AppKitNetwork } from '@reown/appkit-react-native';
import { EthersAdapter } from '@reown/appkit-ethers-react-native';
import { SolanaAdapter } from '@reown/appkit-solana-react-native';
import { BitcoinAdapter } from '@reown/appkit-bitcoin-react-native';
import { storage } from './StorageUtil'; // Import your custom storage
// You can use 'viem/chains' or define your own chains using `AppKitNetwork` type. Check Options/networks for more detailed info
import { mainnet, polygon } from 'viem/chains';
const projectId = 'YOUR_PROJECT_ID'; // Obtain from https://dashboard.reown.com/
const ethersAdapter = new EthersAdapter();
const solanaAdapter = new SolanaAdapter();
const bitcoinAdapter = new BitcoinAdapter();
export const appKit = createAppKit({
projectId,
networks: [mainnet, polygon, solana, bitcoin],
defaultNetwork: mainnet,
adapters: [ethersAdapter, solanaAdapter, bitcoinAdapter],
storage,
// Other AppKit options (e.g., metadata for your dApp)
metadata: {
name: 'My Awesome dApp',
description: 'My dApp description',
url: 'https://myapp.com',
icons: ['https://myapp.com/icon.png'],
redirect: {
native: "YOUR_APP_SCHEME://",
universal: "YOUR_APP_UNIVERSAL_LINK.com",
},
}
});
3. Provide AppKit Instance
Wrap your application with the AppKitProvider
to make the AppKit
instance available throughout your component tree via context.
// App.tsx
import "@walletconnect/react-native-compat";
import React from 'react';
import { SafeAreaProvider } from 'react-native-safe-area-context';
import { AppKitProvider } from '@reown/appkit-react-native';
import { appKit } from './AppKitConfig'; // Your configured AppKit instance
import YourAppRootComponent from './YourAppRootComponent';
function App() {
return (
<SafeAreaProvider>
<AppKitProvider instance={appKit}>
<YourAppRootComponent />
</AppKitProvider>
</SafeAreaProvider>
);
}
export default App;
4. Render AppKit UI
To display the AppKit modal and other potential UI elements, you need to include the <AppKit />
component in your application. If you want the modal to be accessible from anywhere in your app, it’s best to place this component within your main application root component (e.g., the YourAppRootComponent
from the example above, or directly in App.tsx
if it serves as your main layout).
// YourAppRootComponent.tsx (or App.tsx if it contains your main layout)
import React from 'react';
import { AppKit } from '@reown/appkit-react-native';
// ... other imports for your app components.
function YourAppRootComponent() {
return (
<>
{/* Your application's content */}
{/* Add the AppKit component here to render its UI */}
<AppKit />
</>
);
}
export default YourAppRootComponent;
Expo Android Modal Issue: If you’re using Expo Router and the modal doesn’t open on Android, you may need to wrap the <AppKit />
component in a View with absolute positioning. Here’s the workaround:import { View } from 'react-native';
// Replace the simple <AppKit /> with:
<View style={{ position: "absolute", height: "100%", width: "100%" }}>
<AppKit />
</View>
This is a known issue with Expo Router on Android and this workaround resolves the modal rendering problem.
5. Using AppKit in Components
You can now access AppKit functionalities (like connecting, getting account state, etc.) using hooks provided by the library.
// components/ConnectButton.tsx
import { useAppKit, useAccount } from '@reown/appkit-react-native';
function ConnectButton() {
const { open, disconnect } = useAppKit();
const { address, isConnected, chainId } = useAccount();
if (isConnected) {
return (
<div>
<p>Connected to: {chainId}</p>
<p>Address: {address}</p>
<button onClick={() => disconnect()}>Disconnect</button>
</div>
);
}
return <button onClick={() => open()}>Connect Wallet</button>;
}
export default ConnectButton;
For detailed examples on specific actions like signing messages, sending transactions, or switching networks, please refer to the Hooks and Examples sections.
Pre-built Components
AppKit includes pre-built components to speed up your development:
<AppKitButton />
- A pre-styled connect button
<AppKitAccountButton />
- A button showing account information when connected
For detailed information about all available components, hooks, and examples for specific actions like signing messages, sending transactions, or switching networks, see the Components, Hooks, and Examples documentation.
Enable Wallet Detection
Optional feature - This detects wallets installed on the user’s device and enhances the user experience by:
- Showing a green checkmark next to installed wallets
- Prioritizing installed wallets at the top of the wallet selection list
All 600+ wallets in the AppKit ecosystem work via WalletConnect protocol regardless of this configuration. You only need to add the wallets your users most commonly have installed.
To enable AppKit to detect wallets installed on the device, you can make specific changes to the native code of your project.
To enable AppKit to detect wallets installed on the device in your Expo project for iOS, follow these steps:
- Open your
app.json
(or app.config.js
) file.
- Locate the ios section within the configuration.
- Add the
infoPlist
object if it doesn’t exist, and within it, include the LSApplicationQueriesSchemes
array. This array will contain the desired wallet schemes you want to detect.
- Add the wallet schemes to the
LSApplicationQueriesSchemes
array.
Your configuration should look like this:{
"expo": {
"ios": {
"infoPlist": {
"LSApplicationQueriesSchemes": [
"metamask",
"trust",
"safe",
"rainbow",
"uniswap"
// Add other wallet schemes names here
]
}
}
}
}
Connectors
Optional feature - These connectors are only needed if you want to support specific wallets that use custom connection protocols. All 600+ wallets in the AppKit ecosystem work via WalletConnect protocol regardless of this configuration.
AppKit supports various custom connectors for specific wallets that use their own connection protocols. These connectors allow you to integrate popular wallets like Coinbase and Phantom directly into your AppKit configuration.
Coinbase
Coinbase Wallet is a popular wallet that uses a custom connection protocol. To enable it in your AppKit configuration, you’ll need to install the Coinbase SDK and add a specific connector.
Expo Compatibility: Coinbase SDK works with Expo Prebuild but not with Expo Go. You’ll need to use expo prebuild
to generate native code before building your app.
To enable Coinbase Wallet, follow these steps:
- Enable Expo Modules in your project:
npx install-expo-modules@latest
- Install the Coinbase SDK and our custom connector:
yarn add @coinbase/wallet-mobile-sdk @reown/appkit-coinbase-react-native react-native-mmkv
- Run pod-install:
-
Set up deeplink handling in your project following the React Native docs
-
Add Coinbase package configuration to your native files:
// AndroidManifest.xml
<queries>
<!-- other queries -->
<package android:name="org.toshi" />
</queries>
// Info.plist
<key>LSApplicationQueriesSchemes</key>
<array>
<!-- other schemes -->
<string>cbwallet</string>
</array>
- Add the custom connector to your
extraConnectors
:
// src/AppKitConfig.ts (or wherever you prefer to configure it)
import "@walletconnect/react-native-compat";
import { createAppKit } from '@reown/appkit-react-native';
import { MMKV } from 'react-native-mmkv';
import { CoinbaseConnector } from '@reown/appkit-coinbase-react-native';
export const appKit = createAppKit({
// ...
extraConnectors: [
new CoinbaseConnector({ storage: new MMKV() })
],
// ...
});
- Add the Coinbase response handler to process wallet responses:
import { handleResponse } from "@coinbase/wallet-mobile-sdk";
// Add this to your app's deeplink handling code
useEffect(() => {
const sub = Linking.addEventListener("url", ({ url }) => {
const handledBySdk = handleResponse(new URL(url));
if (!handledBySdk) {
// Handle other deeplinks
}
});
return () => sub.remove();
}, []);
For more detailed information, check the Coinbase docs.
Phantom & Solflare
Phantom and Solflare are popular wallets on the Solana blockchain. Because they use a custom connection protocol, it requires a specific connector to be added to your AppKit configuration.
To enable Phantom Wallet, you’ll need to import the PhantomConnector
or SolflareConnector
from @reown/appkit-solana-react-native
and add it to the extraConnectors
array in your createAppKit
configuration.
Here’s how to update your AppKitConfig.ts
file, using the example from the Implementation section as a base:
// src/AppKitConfig.ts (or wherever you prefer to configure it)
import "@walletconnect/react-native-compat";
import { createAppKit } from '@reown/appkit-react-native';
import { SolanaAdapter, PhantomConnector, Solflare } from '@reown/appkit-solana-react-native';
export const appKit = createAppKit({
// ...
extraConnectors: [
new PhantomConnector({ cluster: 'mainnet-beta' }), // Or 'devnet', 'testnet'
new SolflareConnector({ cluster: 'mainnet-beta' }) // Or 'devnet', 'testnet'
],
// ...
});
The cluster
option can be set to 'mainnet-beta'
, 'devnet'
, or 'testnet'
depending on which Solana cluster you want to connect to.
Examples
Test Apps
Want to see AppKit in action? Download our sample AppKit apps below and explore what it can do. Enjoy! 😊
Getting Support 🙋
Reown is committed to delivering the best developer experience.
If you have any questions, feature requests, or bug reports, feel free to open an issue on GitHub