A user creates a wallet on MetaMask, generates a seed phrase, and now wants to import that account into Rabby Wallet for comparison or consolidation. They enter the 12 or 24 words in the correct order, but the application rejects it. Another user has a hardware Ledger connected to Rabby, but the imported addresses do not match what appeared on the device’s screen during initial setup. A third user exports a private key from Trust Wallet and attempts to import it into Rabby, only to find that the imported address does not correspond to the funds they expected. These scenarios are not exotic failures. They are common friction points in wallet management, and each one has a different root cause.

Import errors in a crypto wallet extension can result from seed phrase transcription mistakes, derivation path mismatches, incorrect private key formats, or network configuration issues. Because Rabby Wallet supports multiple account creation and import methods—including seed phrases, private keys, hardware wallet connections, MetaMask integrations, and WalletConnect links to mobile wallets—the troubleshooting path depends on which method failed and at what step. Understanding the diagnostic categories and the underlying technical requirements can convert a frustrating dead end into a targeted repair.

Seed phrase import rejection and verification basics

A seed phrase is a sequence of words, typically 12 or 24, that encodes entropy and serves as the cryptographic root for a hierarchical deterministic wallet. When a user imports a seed phrase into Rabby, the application checks that each word belongs to the standard BIP39 wordlist, validates the checksum (a mathematical verification that the phrase was entered correctly), and then derives addresses using a standardized derivation path.

The checksum verification is the first gate. A seed phrase is not simply a random string of valid words; the final word contains error-correction information. If a user has transcribed or copied the phrase and one character is incorrect, or if a word is replaced with a similar-sounding word that is still valid on the BIP39 list, the checksum will fail and Rabby will reject the import. The most common causes are transposition errors (swapping two words), homophone confusion (for example, confusing “wine” and “whine” if both exist in the wordlist, which they do not, but illustrating the type of mistake), or copying from an untrusted source such as a screenshot rather than the original backup.

If the seed phrase passes the checksum, Rabby derives the first address using a default derivation path. For Ethereum and EVM-compatible networks, this is typically m/44’/60’/0’/0/0, which follows the BIP44 standard for Ethereum. If the user imported the seed into a different wallet (such as MetaMask or Trust Wallet) using the same derivation path, the address should match. If it does not, the issue is likely path divergence, which requires manual path adjustment.

A user encountering “invalid seed phrase” or “checksum failed” messages should first verify the phrase word by word against the original written backup. This means comparing letter by letter, not trusting memory or a digital copy that may have been corrupted. If the phrase is correct and Rabby still rejects it, the user should test the phrase in another wallet application (such as a temporary MetaMask import) to confirm that the problem is not the seed phrase itself but rather Rabby’s validation logic, which would be extremely rare and would warrant a bug report to the Rabby developers.

Derivation path mismatches and address discrepancies

Two wallets given the same seed phrase will produce the same addresses only if they use the same derivation path. A derivation path is an address index within the hierarchical structure, written as m/44’/60’/0’/0/n, where each position represents a choice. Changing any position produces a different address. MetaMask, by default, uses m/44’/60’/0’/0/0 for the first account. Ledger devices use the same path for Ethereum. However, some wallets (particularly older or non-standard implementations) may use m/44’/60’/0’/0′ or other variants.

Rabby Wallet displays the derivation path for imported seed phrases and allows users to manually adjust it. If a user imports a phrase and the resulting address does not match what they expected, the path is the first suspect. Navigate to the account settings within Rabby and look for the derivation path field. Compare it to the path used by the original wallet. If different wallets generated the seed phrase (for example, a phrase created on Ledger and later imported to MetaMask), the derivation path may have been standardized during that import, and Rabby may need a manual adjustment to match.

A second source of address mismatch is account index. Within a given derivation path, wallets can create multiple accounts. The first account typically uses index 0, the second uses index 1, and so forth. If a user created a second account in MetaMask (or a hardware wallet) and that account is the one they want to import, they must either adjust the account index in Rabby to match or accept that the first address generated by the import will not match. Some users assume that importing a seed phrase will automatically find all their accounts; Rabby requires explicit path or index adjustment to reach accounts beyond the first.

When debugging address discrepancies, create a test scenario: import the seed phrase into MetaMask and confirm that MetaMask shows the same address as the original wallet. If it does, Rabby should also show that address with the default path. If Rabby shows a different address, adjust the path in Rabby’s settings one element at a time until the address matches. Document the correct path for future reference, as you may need to provide it to support or use it when importing into other applications.

Private key import format and conversion errors

A private key is a 256-bit number that controls cryptocurrency assets associated with an address. When importing a private key into Rabby, the key must be in the correct format. The two common formats are hexadecimal (a string of 64 hexadecimal characters, each representing 4 bits) and WIF (Wallet Import Format, a Base58Check-encoded string used by Bitcoin and some other systems).

Ethereum and EVM-compatible networks use hexadecimal private keys. A valid Ethereum private key is 64 characters long, consisting of digits 0–9 and letters a–f, and is often prefixed with “0x” for clarity. Some wallets or export functions produce the key without the prefix. Rabby should accept either format, but users should verify whether the application requires the “0x” prefix before attempting import. If a user copies a key from an external source and pastes it into Rabby without verification, and the paste included extra whitespace or line breaks, the import will fail.

Bitcoin and some other networks use WIF format for private key export and import. This format is distinct from Ethereum’s hexadecimal format and is not directly portable. If a user exports a Bitcoin private key from Trust Wallet as a WIF and attempts to import it into Rabby as if it were an Ethereum key, the import will fail because Rabby will not recognize the format or the address will not match. The user must instead use Rabby’s private key import specifically for the Bitcoin or other UTXO-based network.

A common error occurs when a user relies on screenshots or copies a key from a web-based wallet export. Truncation, compression, or invisible characters can damage the key. The safest approach is to manually transcribe the key character by character if doing so manually, or to use a direct file export if the source wallet provides one. If the import fails after the first attempt, do not repeat it without verifying the key format and completeness. Rabby will continue to reject an incomplete or malformed key regardless of how many times the attempt is made.

Hardware wallet connection and signature issues

Rabby integrates with hardware wallets including Ledger, Trezor, GridPlus, OneKey, Keystone, BitBox02, and CoolWallet. These devices store private keys and sign transactions without exposing the keys to the computer or browser. A successful hardware wallet connection requires that the device is physically connected (via USB or Bluetooth), unlocked, and configured with the correct application open (such as the Ethereum app on a Ledger device).

When importing a hardware wallet into Rabby, the wallet generates a public key and derives addresses on the device itself. The public keys and addresses are then cached by Rabby so that the user can view balances and transaction history without the device connected. However, if the hardware device is updated or the firmware changes, the derivation path may shift, and the addresses shown in Rabby may no longer match what the device will display when prompted to sign a transaction.

A mismatch between Rabby’s displayed address and the address shown on the hardware device screen during a transaction is a serious red flag that must be resolved before signing. This can occur if Rabby is using a different derivation path than the device. Navigate to Rabby’s account settings for the hardware wallet, look for path or account configuration options, and compare them to what the hardware wallet itself reports. Most hardware devices have a settings menu or companion application that displays the currently active derivation path. If the paths do not match, adjust Rabby’s settings to sync with the device.

Another issue is browser or USB driver compatibility. Some versions of Chrome or Chromium-based browsers have better USB access than others. If Rabby cannot detect a connected Ledger or Trezor, try a different browser or computer, and ensure that any required drivers (such as Ledger Live drivers on Windows) are installed and up to date. If the device appears in Ledger Live but not in Rabby, the problem is likely a browser-to-device communication issue rather than a wallet import problem, and restarting both the browser and the device often resolves it.

MetaMask account import and secret recovery phrase compatibility

MetaMask stores account information using a secret recovery phrase (effectively a seed phrase) and uses the derivation path m/44’/60’/0’/0/n by default for Ethereum accounts. When a user exports a secret recovery phrase from MetaMask and attempts to import it into Rabby, the import usually succeeds if the phrase is transcribed correctly and if both wallets use the default path.

However, MetaMask also allows users to import private keys directly into the MetaMask extension in addition to accounts derived from the seed phrase. These private key accounts are not derived from the seed phrase and cannot be recovered by importing the seed phrase alone into another wallet. If a user has added accounts to MetaMask by importing private keys, and then expects those accounts to appear when importing the MetaMask seed phrase into Rabby, they will be disappointed. Only the accounts derived from the seed phrase using the standard path will appear. The private key accounts must be imported separately into Rabby by exporting the private keys from MetaMask and using Rabby’s private key import feature.

Additionally, MetaMask uses the Infura infrastructure for gas price estimation, balance checking, and network data. When a user imports a MetaMask account into Rabby, the account itself is portable, but Rabby uses its own network infrastructure. A user might notice that Rabby displays a different gas estimate or account balance than MetaMask. This is not a problem with the import; it reflects differences in how the two wallets query network data. Both will eventually show the same balances once all network requests complete.

Mobile wallet connection via WalletConnect and desktop sync

Rabby supports connections to mobile wallets such as MetaMask Mobile, Trust Wallet, TokenPocket, imToken, and others via WalletConnect. This does not import the wallet; instead, it creates a bridge where the mobile app controls the account and Rabby acts as a viewing and transaction interface.

A WalletConnect failure typically manifests as a QR code that fails to scan, a connection that times out, or a mobile app that does not respond to connection requests. First, ensure that both the desktop browser (running Rabby) and the mobile wallet app are on the same WiFi network, or that the network is not blocking local connections. Some corporate or school networks restrict local device communication. Second, verify that the mobile wallet app is fully updated; WalletConnect protocol versions can change, and an older app may not recognize a newer QR code format. Third, scan the QR code directly from the Rabby interface; do not retype or manually construct the connection string, as this is error-prone.

If the connection succeeds but accounts do not appear, the mobile wallet may not be set to the network that Rabby is querying. Check that the network selector in both Rabby and the mobile app are set to the same chain. If still no accounts appear, reset the WalletConnect session by disconnecting in both applications and reconnecting from scratch. Some mobile wallets require explicit permission to share account information with desktop dapps; check the mobile app’s account or permissions settings.

Watch-only accounts and address-only imports

Rabby allows users to add addresses in watch-only mode, meaning that the user can view balances and transaction history without holding the private key. This is useful for monitoring an exchange’s cold storage address, a hardware wallet stored offline, or a friend’s public account. A watch-only import cannot fail in the way a seed phrase or private key import can, because Rabby is only storing a public address and querying public blockchain data.

However, if a user adds an address as watch-only and later realizes they intended to import the full account (including the ability to sign transactions), they cannot upgrade the watch-only account without removing and reimporting it with the private key or seed phrase. Some users add an address as watch-only as a test, and then expect to later “unlock” it with the private key. Rabby does not support this workflow. The workaround is to note the watch-only address, remove it, and then perform a proper import with the private key or seed phrase.

Additionally, if a user imports a contact address (a saved public address for a counterparty) and then later realizes that they actually wanted to import their own account, Rabby does not provide a direct conversion. The contact is a reference only. The user must identify their own account separately and import it using the appropriate method.

Institutional wallet integration and Safe/Cobo import

Rabby integrates with institutional wallets including Safe, Cobo, Argus, Amber, and Fireblocks. These integrations are not the same as importing a seed phrase. Instead, they create connections that allow Rabby to interact with accounts controlled by multisig contracts or custodial services. A Safe account, for example, is a smart contract on Ethereum that requires multiple signatures to move funds, and Rabby can propose and sign transactions on behalf of one of the signers.

When importing or connecting to a Safe, Rabby may fail if the Safe contract is not deployed on the network that Rabby is currently querying, or if the user’s address is not listed as a signer on the Safe. Verify that Rabby is set to the correct network, and confirm the Safe’s contract address by checking the blockchain explorer. If the contract address is correct but Rabby still cannot connect, the issue may be that the Safe uses a non-standard signing scheme or that the network endpoint Rabby is using is not returning contract data. Try switching to a different RPC endpoint within Rabby’s network settings.

For Cobo and other custodial wallets, the integration is typically via an API key or authentication token. If the integration fails, the API key may have expired, been revoked, or entered incorrectly. Refer to the custodial service’s API documentation and regenerate or verify the key. Do not share API keys with anyone other than Rabby, and do not paste them into a browser console or untrusted application.

General troubleshooting steps and validation before import

Before attempting to import an account into Rabby, a user should validate the source material. If importing a seed phrase, write down the phrase word by word from the original source, not from a screenshot or digital copy. If importing a private key, export it directly from the source wallet and avoid copying it through multiple intermediate applications or text editors. If connecting a hardware wallet, ensure the device is in good condition and has the correct firmware version installed.

After an import attempt fails, do not immediately repeat it with the same input. Instead, examine what the error message says. Common messages include “invalid seed phrase,” “checksum failed,” “address already in use,” and “network error.” Invalid seed phrase or checksum failed indicates a data entry or format problem. Address already in use typically means the account is already present in Rabby (perhaps under a different name), and the user can simply activate it. Network error suggests a temporary connectivity issue; wait a few seconds and try again.

If an import succeeds but the resulting account does not match the expected address, do not assume the import was wrong. Instead, open the account details in Rabby and check the derivation path, account index, and network. Compare these settings to the source wallet. If they differ, adjust them in Rabby’s settings and watch the displayed address update in real time. Most address discrepancies resolve with a path adjustment rather than a complete reimport.

For persistent failures where all diagnostic steps have been exhausted, document the exact error message, the import method, the source wallet, and the steps taken. This information is valuable for support requests. Export a hardware wallet’s current signing path from its companion app, save a screenshot of the expected address from the source wallet, and provide the network and account index. With this information, a support representative can typically identify the issue or escalate it to the developers if it represents a genuine bug.