Trezor Suite Web Network Selection: Understanding Mainnet, Testnet, and Custom RPC Setup

A cryptocurrency user working with Trezor Suite Web needs to move between different blockchain networks depending on the task at hand. Testing a transaction on Ethereum’s Sepolia testnet before committing real funds to mainnet. Connecting to a personal Ethereum node instead of Infura. Swapping assets on a Layer 2 network like Polygon or Arbitrum. These operations require network awareness and, in many cases, the ability to change RPC endpoints. The interface must make that process clear and safe, because selecting the wrong network can route a transaction to the wrong blockchain—and recovery depends on understanding which chain received it.

Trezor Suite Web provides network selection tools that sit between convenience and control. The application recognizes major blockchains—Ethereum, Bitcoin, Polygon, Arbitrum, and others—with preconfigured endpoints. For users running their own nodes or connecting to custom infrastructure, the ability to specify a custom RPC endpoint becomes essential. Understanding how to navigate these settings, what each network option means, and which endpoints are trustworthy separates a confident operator from someone who accidentally broadcasts to the wrong chain or trusts an endpoint that monitors their activity.

Mainnet versus testnet: what the difference means in practice

Mainnet is the production blockchain where transactions cost real value and cannot be reversed. Ethereum mainnet, Bitcoin mainnet, Polygon mainnet—each is the live network where funds have genuine economic weight. Testnet is a parallel chain designed for development and experimentation. Sepolia on Ethereum, testnet on Bitcoin, Mumbai on Polygon—these networks use test coins that have no market value. A transaction on testnet uses computational resources and generates a record on that test blockchain, but it produces no economic consequence.

The distinction matters because it prevents a category of human error. A developer building on Ethereum, for instance, may want to verify a smart contract interaction before executing it on mainnet with real ETH. By first testing on Sepolia, the developer confirms that the transaction structure is valid, the contract call completes, and the response is as expected. The test transaction appears on Sepolia’s public ledger indefinitely, but it involved no real funds. If something goes wrong—if the contract reverts, if the gas calculation is off, if the data format is incorrect—no actual loss occurs.

Trezor Suite Web defaults to mainnet for each supported blockchain. That is the sensible default because most users are making real transactions and want to work with the actual network where their funds exist. However, the application must allow switching to testnet without making that process so hidden that a user stumbles onto testnet by accident. The network selector is typically prominent, and each network has a distinct name that cannot be easily confused.

For a user moving from Bitcoin Core or the Electrum wallet to Trezor Suite Web, the testnet concept is familiar. For users migrating from a Web3 wallet like MetaMask or Trust Wallet, the interface pattern may be slightly different, but the principle is the same: choose the network explicitly, verify it is the correct one, then broadcast. The risk is not in the feature itself. It is in distraction or fatigue leading a user to approve a transaction without checking the network display.

Trezor Suite Web and public RPC endpoints

An RPC endpoint is a URL that the wallet uses to communicate with a blockchain. It submits transaction requests, reads account balances, and retrieves historical data. When a user opens Trezor Suite Web and selects Ethereum mainnet, the application connects to an RPC endpoint by default—often a public service provided by Infura, Alchemy, or similar infrastructure operators. That connection is necessary; without it, the wallet cannot interact with the blockchain.

Public RPC endpoints have two important consequences. First, they allow the infrastructure provider to see which addresses are being queried. If a user connects to Infura and requests the balance of their address, Infura’s servers log that query. This is not unique to Trezor Suite Web. Every wallet that connects to a public RPC endpoint creates some visibility into its activity. Hardware wallets like Trezor are valuable precisely because the private key remains on the physical device; the web or mobile application cannot steal it. However, the application’s network requests can still reveal patterns.

Second, public RPC endpoints can fail, rate-limit requests, or change their service terms. A major infrastructure provider experiencing an outage affects every wallet connected to it. A user attempting a time-sensitive transaction might face delays. This is why redundancy and alternatives matter. Trezor Suite Web can be configured to use different endpoints, and advanced users may run their own nodes to eliminate the dependency entirely.

The preconfigured endpoints in Trezor Suite Web are selected for reliability, but they remain someone else’s infrastructure. Users who want stronger privacy or independence should consider the custom RPC endpoint feature, which allows pointing the wallet to any compatible endpoint. This creates a design pattern where Trezor Suite Web becomes a blockchain wallet interface that can connect to multiple data sources, rather than being locked into one provider’s view of the network.

Setting up and validating custom RPC endpoints

A custom RPC endpoint is typically a URL like http://192.168.1.100:8545 (for a local Ethereum node) or https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY (for a third-party provider). Trezor Suite Web accepts this input in the network settings, usually under an “Advanced” or “Custom RPC” section. The application then redirects all network requests for that blockchain through the specified endpoint instead of using the default.

Before saving a custom endpoint, a user should validate that it is actually responding to requests and that it is the correct endpoint for the desired network. Pasting a wrong URL, a testnet endpoint for a mainnet selection, or a typo in a local IP address can cause the wallet to fail silently or show outdated balance information. A simple validation is to open the endpoint URL in a browser or use a command-line tool like curl to check whether it responds to a basic JSON-RPC request, such as {"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}.

Running a local Ethereum node—using Geth, Erigon, Nethermind, or similar clients—requires significant disk space (several hundred gigabytes for a full archive node) and bandwidth. A lighter alternative is running a light client or connecting to a local validator setup if staking. For users who do not want to operate infrastructure, using a private RPC endpoint from a trusted provider (where the user controls an API key and the endpoint is not shared) offers a middle ground between full decentralization and accepting a public provider’s visibility.

The security model shifts once a custom endpoint is in use. Trezor Suite Web still controls the private key through the hardware wallet; the RPC endpoint controls the information it receives. An RPC endpoint operated by an attacker or compromised by surveillance could serve false balance data, present fabricated transaction history, or suggest inflated gas prices. The wallet cannot verify the accuracy of responses from the RPC endpoint; it trusts them. This is why running your own node or using an endpoint you control or trust is essential if the RPC provider’s trustworthiness matters to your threat model.

Network configuration for Layer 2 and alternative chains

Ethereum mainnet is one chain, but blockchain activity increasingly happens on Layer 2 networks like Polygon, Arbitrum, Optimism, and Base. These networks are separate blockchains with their own RPC endpoints, smart contracts, and ecosystems. A token balance on Polygon mainnet is not the same as a balance on Ethereum mainnet, even if the token has the same symbol. Bridging or swapping between chains is a deliberate action, not automatic.

Trezor Suite Web includes several Layer 2 networks in its preconfigured list. When a user selects Polygon from the network dropdown, the application switches to Polygon’s RPC endpoint and displays balances and activity for that chain. This is one reason why decentralized wallet interfaces need clear network indicators. A user who is not paying attention might believe their funds are on Ethereum when they are actually on Polygon, or vice versa. The solution is redundant display: show the network name in the transaction confirmation, in the balance view, and in the address display whenever possible.

Adding a custom Layer 2 network in Trezor Suite Web requires knowing its RPC endpoint, chain ID, and currency symbol. Most chains publish this information in their documentation. For instance, Arbitrum One has chain ID 42161 and uses endpoints published by Offchain Labs. A user adding a custom Layer 2 endpoint should verify these details from an official source, not from a forum post or social media message, because a malicious configuration could route transactions to an attacker-controlled chain.

The stakes are higher with custom chains because blockchain explorers and community awareness are less mature than for Ethereum or Bitcoin. If a transaction fails or behaves unexpectedly on a lesser-known Layer 2, debugging becomes harder. It is worth testing a small transaction first, confirming it appears on the correct blockchain explorer, and verifying the receiving address before sending larger amounts.

Testnet faucets and acquiring test funds

To test transactions on testnet, a user needs testnet coins. These are obtained from a faucet—a service that distributes small amounts of test coins for free. Ethereum Sepolia faucets, Polygon Mumbai faucets, and Bitcoin testnet faucets exist specifically for this purpose. A faucet typically asks for a wallet address, performs a CAPTCHA or other rate-limiting check, and sends a small amount of test coins to that address.

Trezor Suite Web can generate receive addresses on testnet the same way it does on mainnet. The user selects the testnet version of the desired blockchain, generates an address, copies it, visits a faucet website, pastes the address, and waits for the faucet transaction to confirm. Once test coins arrive, they can be used to test sending, receiving, swapping, or interacting with smart contracts.

An important practice is to keep testnet and mainnet accounts visually distinct. Use different receive addresses, avoid copying a mainnet address and pasting it into a testnet faucet form by accident, and check the network display in Trezor Suite Web before requesting or sending coins. Hardware wallets like Trezor reduce the chance of accidentally approving a wrong transaction through physical confirmation, but that benefit applies only if the user is paying attention to what is being confirmed on the device screen.

Testnet activity is permanent in the sense that transactions appear on the public testnet ledger indefinitely. Privacy considerations apply to testnet too: addresses used on testnet could be linked to a user if the address format or transaction pattern is distinctive. It is therefore reasonable to treat testnet like a staging environment with different address practices than mainnet, rather than assuming it is entirely anonymous.

Connecting Trezor Suite Web to external wallets and applications

Trezor Suite Web is primarily a direct interface for managing a Trezor hardware wallet. However, the device can also be connected to other applications. MetaMask, Electrum, and Wasabi Wallet all support Trezor as a signing device. When a user connects their Trezor to MetaMask, for instance, MetaMask becomes the interface but Trezor remains the key keeper. The user approves transactions physically on the Trezor device, not in MetaMask.

This distinction is important because it affects network selection. When MetaMask is connected to a Trezor, the network chosen in MetaMask is what matters. Trezor Suite Web might be showing Ethereum mainnet, but if MetaMask is switched to Polygon, a transaction approved on the Trezor will be broadcast to Polygon. The hardware wallet does not independently verify which network the external application claims to be using; it only confirms that the user has instructed it to sign something.

For users who want to use Trezor with MetaMask or other Web3 wallets, this arrangement is actually more secure than using MetaMask alone, because the private key stays on the Trezor device. However, it creates a responsibility: the user must verify the network in both the external wallet and on the Trezor’s physical screen before confirming. The trezor suite web application is designed to make this verification easier by providing a clear, dedicated interface, but the user must still consciously switch between applications when using external wallet software.

Some users prefer this arrangement because it allows them to consolidate multiple hardware wallet brands under one ecosystem, or to use a single wallet application for all their assets across different chains and hardware. Others prefer the native Trezor Suite Web because it integrates directly with the device and provides a consistent experience without switching between applications.

RPC reliability, privacy, and performance trade-offs

Choosing an RPC endpoint involves trade-offs. A public endpoint like Infura is reliable and fast because it is well-maintained infrastructure serving thousands of users, but it sees every query. A private RPC endpoint from a commercial provider (where you control an API key) reduces visibility to that provider but still concentrates dependency on one company. Running your own node gives you complete independence and privacy but requires hardware, bandwidth, disk space, and ongoing maintenance.

There is no universal right answer. A user handling small transactions, testing on testnet, or casually checking balances might reasonably use a public endpoint and accept the visibility trade-off. A user regularly moving significant value, engaging in trading that should not be front-run, or philosophically opposed to surveillance might justify the cost and complexity of running a node. Most users fall somewhere in the middle and use a commercial private endpoint, possibly with fallback to a public endpoint if the primary is unavailable.

Trezor Suite Web makes this choice transparent by allowing RPC configuration. A user is not locked into one provider and can switch endpoints as circumstances change. However, the application should still make clear to less technical users that public RPC endpoints do see network activity. A small label, an informational tooltip, or a link to documentation explaining the difference between public and private endpoints can improve decision-making without overwhelming the interface.

Practical workflows: testing, migration, and recovery

Three common workflows illustrate how network selection matters. First, testing: a user is preparing a larger transaction and wants to rehearse it on testnet first. They switch Trezor Suite Web to Sepolia, acquire test ETH from a faucet, and execute the exact sequence they plan for mainnet. This reveals any issues—insufficient gas, contract errors, incorrect parameters—before real funds are at risk. The testnet experience should be identical to mainnet experience, which is why Trezor Suite Web must support testnet with the same features and clarity.

Second, migration: a user is moving funds from one hardware wallet to another, or from a software wallet to a hardware wallet, and wants to verify the destination before committing funds. They might send a small amount first, confirm it arrives at the correct address on the blockchain, and then send the rest. Trezor Suite Web’s balance monitoring and transaction history allow tracking these partial transfers. The network must be correct and constant throughout; switching networks mid-migration is a critical error.

Third, recovery: a user has a Trezor device with funds but has lost access to their usual management interface and needs to recover their balance. They may need to configure a custom RPC endpoint pointed at their own node or a trusted provider, or they may need to switch to testnet to verify that their recovery phrase works before attempting mainnet access. The ability to configure networks flexibly becomes a recovery tool.

In each workflow, the risk is reduced by verification: checking the network display, confirming the receiving address is correct, monitoring the transaction on a blockchain explorer, and testing with small amounts before committing significant value. Trezor Suite Web’s tools support these practices, but they require the user to engage deliberately rather than rushing through the process.