Rabby iOS vs Android Feature Parity: What You Lose When Switching Between Mobile Platforms

A Web3 user managing assets across multiple EVM-compatible chains faces a practical choice when moving from Android to iOS, or vice versa. Rabby Wallet mobile versions exist on both platforms, but they do not function identically. The differences are not cosmetic UI variations or minor timing delays. They represent fundamental capability gaps rooted in Apple’s App Store policies, which restrict cryptographic functionality and certain blockchain interactions in ways that Android’s more permissive environment does not enforce. For users accustomed to the full Rabby Wallet mobile experience on one platform, switching to the other involves discovering which features have been removed, which workflows have been redesigned, and what workarounds now become necessary.

Understanding those gaps matters before migration, not after. A user who has relied on specific transaction approval workflows, chain interactions, or security features on Android may assume the iOS version provides equivalent capability. It often does not. The restrictions are not Rabby’s fault; they reflect Apple’s requirements for any application handling cryptographic keys or blockchain interactions. But the practical result is the same: feature parity between Rabby Wallet iOS and Rabby Wallet Android is incomplete, and the direction of the gap is asymmetrical. Users moving from Android to iOS encounter removal. Users moving from iOS to Android encounter unexpected capability.

Apple’s restrictions on cryptographic operations and their practical scope

Apple’s App Store policies place strict limits on how applications can handle cryptographic keys, request permissions, and execute blockchain-related functions. The wallet must use only Apple’s approved cryptographic libraries, must not allow users to export private keys in certain formats, and must route certain security-sensitive operations through system-level security frameworks. These are not arbitrary limitations. They exist to prevent malicious applications from extracting cryptographic material, and to ensure that only the user can authorize sensitive actions. However, the implementation of these restrictions has a side effect: some advanced or less common blockchain interactions become unavailable or must be redesigned.

Rabby Wallet Android operates under Android’s permission model, which is more granular and more permissive. An Android user can grant specific permissions for camera access, clipboard, file storage, and network operations, and an application can use those permissions to perform functions that iOS blocks entirely. For instance, Android allows direct clipboard operations in certain contexts, which enables smoother QR code scanning and address importing workflows. iOS restricts clipboard access more aggressively, requiring users to paste values through specific system dialogs rather than allowing an app to read or write directly.

The chain-of-custody for recovery phrases and private keys illustrates the practical impact. Both platforms keep keys encrypted on the device, but iOS enforces additional restrictions on how the encryption keys themselves are derived and stored. Rabby Wallet on iOS uses Keychain, Apple’s secure enclave-backed storage, which is more restrictive than Android’s equivalent. This means that while both platforms protect the key material, the workflow for backing up, importing, or recovering access differs. An iOS user cannot simply export the recovery phrase in plain text through the app’s UI, while an Android user can. The Android approach places more responsibility on the user to store the backup safely; the iOS approach removes the option entirely and forces reliance on the system recovery mechanism.

Hardware integration with external signing devices such as Ledger also faces platform-specific constraints. Rabby Wallet Android supports connection to Ledger and other hardware wallets through Bluetooth with more flexibility, while Rabby Wallet iOS limits such integrations due to Apple’s restrictions on how applications can interface with external devices. The limitation affects not just the initial connection, but the workflow each time a transaction requires a hardware signature. This difference can make hardware wallet integration practical on Android and impractical on iOS for users who do not have a desktop version available.

Feature removal when moving from Android to iOS

The most disruptive transition occurs when a user switches from Android to iOS. Functions that work seamlessly on Android either disappear, become restricted, or require a desktop workaround. One critical area is the handling of custom networks and RPC endpoints. Rabby Wallet Android allows users to add custom EVM-compatible chains with custom RPC endpoints with minimal friction. A user can specify a network name, RPC URL, chain ID, and currency symbol, then immediately begin using that network. Rabby Wallet iOS restricts this capability significantly. Custom networks can still be added, but the process involves more stringent validation, and certain network configurations—particularly those involving non-standard or less established chains—may be rejected by the App Store version.

Clipboard operations represent another area of reduction. Android allows applications to read from and write to the clipboard without explicit user prompts in most cases, which enables rapid workflows: scan a QR code, the wallet parses the address from the clipboard, the user confirms, and the transaction begins. iOS requires explicit user permission for clipboard access, and Apple’s implementation sometimes requires the user to manually paste rather than allowing the app to extract the value directly. For users who manage many addresses or frequently transfer funds between wallets, this friction multiplies quickly.

Token import and custom token addition also differ. Rabby Wallet Android allows users to add contract addresses for any token they hold, even if the token is not listed in major indexing services. iOS restricts custom token addition to tokens that can be verified against Apple’s acceptable lists or through recognized token databases. This means an iOS user holding tokens from smaller projects, testnets, or new launches may find those tokens impossible to add to their wallet view, even if they can transfer them on-chain. The tokens exist on the blockchain, but the iOS app will not display them or acknowledge their balances.

DeFi interaction patterns also change. Many DeFi protocols require users to interact with contract functions that are not pre-approved by Apple’s review process. Rabby Wallet Android can surface a wider range of contract interactions, allowing users to call functions directly or use less common protocol features. iOS restricts interactions to only those that have been validated through the review process or are recognized as standard ERC-20 or NFT operations. A user migrating from Android may discover that the DeFi opportunities they have been using—yield farming on a specific protocol, interacting with governance contracts, or executing complex swaps—are no longer available through the iOS version of the app.

Feature expansion when moving from iOS to Android

The opposite migration, from iOS to Android, presents a different problem: the discovery of capability that was previously unavailable. Users coming from iOS to Android often experience this as unexpected power, but it can also be disorienting. Features that appeared to be universal limitations of Rabby Wallet turn out to be iOS-only restrictions. The Android version supports recovery phrase export, custom RPC endpoints for any EVM-compatible network, clipboard operations without permission dialogs, and direct hardware wallet integration. For a user accustomed to accepting these as inherent limitations of self-custody wallets on mobile, Android can feel liberating.

However, this expanded capability also requires adjusted security awareness. iOS’s restrictive model enforces certain safety practices by preventing unsafe operations. Android permits operations that could be dangerous if executed carelessly. An iOS user moving to Android can now export their recovery phrase directly, which means they must make an intentional choice about how to store it safely. The App Store’s restrictions were, in part, forcing secure practices through constraint. An Android user must choose security; an iOS user had security chosen for them.

Network customization becomes genuinely powerful on Android. A user can add testnets for development, connect to private RPC endpoints for improved privacy, or use Layer 2 chains that were not reviewed by Apple. This is valuable for power users and developers, but it also increases the risk of mistakes. A poorly configured RPC endpoint could be manipulated by a network attacker to show false balances, false transactions, or false receipts. An iOS user accustomed to Apple’s validation of available networks suddenly bears full responsibility for network configuration accuracy.

Token support also expands significantly. Rabby Wallet Android can surface any token on any EVM-compatible chain, regardless of whether it is recognized by major indexing services. This means a user can track holdings across smaller projects, emerging chains, and specialized protocols. It also means they must independently verify that a contract address is correct, and that they are not confusing a legitimate token with a scam token that has a similar name or address.

Why feature parity cannot exist under current platform constraints

The asymmetry between iOS and Android is not a Rabby Wallet design choice that could be changed by engineering effort. It is a consequence of fundamentally different platform policies. Apple reviews applications before they appear on the App Store and enforces guidelines that restrict cryptographic operations, external device integration, and permission models. Apple’s review process is not transparent, and the specific reasons for rejection are often vague. A feature might be rejected because it “could be used to bypass security,” even if the Rabby team designed it with full security in mind. Appealing Apple’s decisions is possible but unreliable, and resubmission can take weeks.

Google’s approach to Android is more permissive, but not arbitrary. Android still reviews applications on the Play Store, and malicious apps are removed. However, the bar for permission to include specific features is lower, and the review process is faster. Android’s permission model is also more transparent: an app declares what it needs, the user sees those permissions, and the user decides whether to grant them. This approach trusts users to understand their choices. Apple’s approach tries to prevent users from making unsafe choices by restricting what applications can do at all.

Both approaches have trade-offs. Apple’s restrictions prevent some attacks, but they also prevent legitimate features. Android’s openness allows more features, but it places more burden on the user to grant permissions responsibly and to trust that the application is using them safely. For a self-custody wallet, where the user bears full responsibility for funds anyway, the philosophical tension is acute. Rabby Wallet cannot simultaneously satisfy Apple’s requirements and provide the same feature set on both platforms.

The situation may evolve as both Apple and Google refine their policies around Web3 applications. Apple has been gradually increasing permitted functionality for cryptocurrency wallets, but the pace of change is slow. Meanwhile, for users making a platform migration decision today, the reality is clear: feature parity does not exist, and the direction of migration matters significantly. Users moving to iOS should inventory the features they currently use on Android and verify that equivalents exist. Users moving to Android should understand that expanded capability requires expanded security responsibility.

Verification and security downloads across platforms

The asymmetry in features also creates asymmetry in the importance of downloading from official sources. Rabby Wallet recommends downloading exclusively through official channels—rabby.io for the browser extension and extension-adjacent tools, and verified app stores for mobile. This recommendation is especially critical on iOS, where App Store review provides at least some assurance that the application has been checked for obvious malware. On Android, Play Store review is less rigorous, and sideloading apps from unknown sources is possible. The combination of greater feature availability and looser sideloading controls on Android means that Android users have more ways to obtain a counterfeit or modified Rabby Wallet.

A counterfeit Rabby Wallet on Android could appear fully functional while secretly logging recovery phrases, private keys, or transaction data. An iOS user moving to Android should be especially careful to download through the official Play Store and verify the publisher. Similarly, an Android user comfortable with sideloading should not assume that iOS version’s App Store requirement makes it automatically safer. Apple’s review process catches some malware, but not all, and the review process focuses on obvious violations rather than subtle key-logging or data exfiltration attacks.

For users who want to avoid these platform-specific risks entirely, this page provides access to the browser extension version, which runs on Chrome, Brave, and Microsoft Edge and avoids both iOS and Android policy constraints. The browser extension is open-source and published on GitHub, allowing for community code review. It is not subject to App Store restrictions, and it provides the full feature set on both platforms. For users who perform frequent transactions or use advanced DeFi protocols, the browser extension often becomes the primary interface, with the mobile apps serving as secondary tools for viewing balances or approving routine transactions.

Practical migration strategies and feature audits

A user planning to switch between iOS and Android should conduct a feature audit before migration. The process is straightforward: document every function currently used on the source platform, verify that an equivalent exists on the target platform, and if not, identify a workaround. For example, if a user is currently using Rabby Wallet Android to add custom RPC endpoints and interact with a specific testnet, they should verify before switching to iOS that the testnet is supported through standard configurations, or prepare to use the desktop or browser extension for that specific workflow. Workarounds often involve keeping one device or browser open for features that the target platform does not support.

Recovery phrase handling deserves special attention during migration. On Android, users can export the recovery phrase directly from the app and store it in a secure location of their choice. On iOS, the recovery phrase can be retrieved through the system backup process, which ties it to iCloud and Apple’s infrastructure. A user switching from Android to iOS should plan for this difference: the iOS backup mechanism is convenient but less portable. A user switching from iOS to Android gains the ability to export the phrase, but must take responsibility for secure storage. In both cases, the recovery phrase itself should never be typed into online services, photographed, or stored in plaintext in cloud sync.

Multi-device workflows also require adjustment. Some users maintain a primary device with full features and a secondary device optimized for specific use cases. An Android user might use their primary device for complex DeFi, custom networks, and hardware wallet integration, while using an iOS device as a secondary device for basic balance checks and simple transfers. This arrangement acknowledges the feature gap and uses each platform for what it does well. The trade-off is that syncing balances, transaction history, and account state across devices requires discipline: Rabby Wallet does not automatically sync wallets between devices, and a user must manage the recovery phrase or accounts carefully to avoid confusion or lost context.

The role of the browser extension for cross-platform consistency

The most reliable way to avoid platform-specific feature gaps is to rely primarily on the Rabby Wallet browser extension for transactions requiring advanced functionality, and use the mobile apps only for routine operations. The extension provides the full feature set on both Windows and macOS, and it is accessible from any browser on any device. A user planning to switch mobile platforms can reduce friction by moving critical workflows to the desktop. DeFi interactions, custom network additions, token imports, and hardware wallet operations become more predictable when executed through the extension rather than through a mobile app.

This approach also improves security in ways unrelated to the platform gap. A desktop browser can display more information about a transaction before signing, can more easily integrate with external tools for verification, and can run in a more controlled environment than a smartphone. Many Web3 users operate with the mobile app for viewing and the browser extension for transacting, treating the mobile interface as a portfolio tracker rather than a full trading terminal. During a platform migration, this architecture becomes especially valuable: the user can keep the extension running on a stable desktop while testing the new mobile platform with less critical transactions.

The browser extension also sidesteps the need to wait for Apple or Google to approve new features or security improvements. When Rabby publishes an update to the extension, users receive it automatically without App Store review delays. Security patches can be deployed faster, new EVM-compatible chains can be supported more quickly, and experimental features can be tested without navigating application review policies. For users migrating to iOS and concerned about losing Android features, the browser extension often becomes the tool that recovers that capability. A few minutes in a browser can accomplish what the iOS app cannot, and the transaction can then be signed through either the mobile app or the extension.

Forward planning as platform policies evolve

Apple’s policies around cryptocurrency wallets have been gradually liberalizing, but the pace is uncertain. New features occasionally become available on iOS that were previously restricted, but the process is slow and unpredictable. Android’s policies are also evolving, particularly as governments increase scrutiny on digital asset management and as major protocols mature. A user should not assume that current feature gaps are permanent, but should also not rely on them being closed quickly. The safer assumption is that iOS and Android will remain asymmetrical for at least the next one to two years, and that platform migration decisions should be made with current capabilities in mind, not future hopes.

Rabby Wallet’s open-source codebase on GitHub provides some transparency into how these platform differences are managed. Users can see the conditional code that handles iOS vs. Android differences, and can track whether Rabby is working on closing gaps. However, many gaps cannot be closed through engineering alone; they require changes to Apple’s App Store policies, which are outside Rabby’s control. This means that advocacy, feedback to Apple, and pressure from the broader Web3 community are also factors in whether feature parity improves.

For an individual user, the practical conclusion is clear: platform choice carries real consequences. iOS provides better security enforcement through restrictive design, while Android provides more features and more flexibility. Neither is universally better. The right choice depends on the user’s threat model, preferred workflows, and tolerance for restricted functionality. A user who values simplicity and is willing to use the browser extension for advanced operations should prefer iOS. A power user who interacts frequently with custom networks, emerging protocols, and hardware wallets should prefer Android. A user who wants to avoid platform-specific choices should plan to use the browser extension as the primary interface and treat the mobile apps as secondary tools.