Base Sepolia public RPC endpoint: chain settings, faucet, and debugging

Base Sepolia is the testnet that mirrors Base mainnet. It runs on the OP Stack and settles to Ethereum Sepolia, so the tooling you use for Base mainnet mostly carries over: the same JSON-RPC methods, the same EVM semantics, and the same wallet flow. The main differences are the chain ID, the explorer, and the fact that the ETH you spend is testnet ETH with no market value.

If you are here because you need a working endpoint right now, start with the chain settings below, add the network to your wallet, and pull testnet ETH from a faucet. If you are wiring Base Sepolia into a CI pipeline or a staging environment, read the section on shared versus managed endpoints before you hard-code anything.

Chain settings at a glance

These are the values you need to add Base Sepolia to a wallet or a client. They match the Base Sepolia network configuration.

A quick note on chain ID: 84532 is Base Sepolia. Base mainnet is 8453. Mixing these up is one of the most common reasons a transaction appears to succeed in your logs but never shows up where you expect it.

Choosing how to connect: shared endpoint or managed RPC

The decision that matters most is not which URL you paste first, it is what kind of endpoint your workload needs. A public endpoint is fine for a single developer testing a contract call. It is a poor fit for a team running integration tests on every pull request, or for a staging app that needs consistent responses during a demo.

Use this table to pick the right shape of endpoint for your situation.

OnFinality provides a public Base Sepolia endpoint for development, and a managed RPC API service when you need more headroom. If your testnet environment is effectively production for your team, a dedicated node removes the shared-endpoint variable entirely.

Adding Base Sepolia to a wallet

Most wallets accept a custom network. The fields map directly to the table above.

{
  "chainId": "0x14a34",
  "chainName": "Base Sepolia",
  "rpcUrls": ["https://base-sepolia.api.onfinality.io/public"],
  "nativeCurrency": {
    "name": "Sepolia Ether",
    "symbol": "ETH",
    "decimals": 18
  },
  "blockExplorerUrls": ["https://sepolia.basescan.org"]
}

Note that the chain ID is written in hex here: 84532 in decimal is 0x14a34. Wallets that ask for a hex chain ID will reject the decimal form, and vice versa. If a wallet refuses to save the network, check the format before you check anything else.

You can also add the network programmatically from a dapp using wallet_addEthereumChain, passing the same object. This is useful when you want users to land on Base Sepolia without manual setup.

Getting testnet ETH from a faucet

Base Sepolia ETH comes from faucets, not from exchanges. You need a small amount to deploy contracts and send test transactions. Faucet availability changes over time, so treat any specific faucet as a starting point rather than a permanent dependency.

A few practical notes:

• Faucets usually require a minimum mainnet balance or a social login to prevent abuse.
• Some faucets drip to a single address per day. If you are testing with a team, use separate addresses.
• Bridge testnet ETH from Ethereum Sepolia if a direct Base Sepolia faucet is unavailable. The official Base bridge supports Sepolia.
• Keep a dedicated test wallet. Do not reuse a wallet that holds mainnet assets.

If a faucet transaction is pending for a long time, check the Base Sepolia explorer for the transaction hash before assuming the faucet failed. Testnet congestion is usually temporary.

Verifying the endpoint with curl and viem

Before you debug application code, confirm the endpoint itself responds. A single eth_chainId call tells you whether you are talking to the right chain.

curl -s https://base-sepolia.api.onfinality.io/public \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

The response should be "0x14a34", which is 84532. If you get a different chain ID, you are pointed at the wrong network. If you get an error, the endpoint or your network path is the problem, not your contract.

From JavaScript, the same check with viem looks like this:

import { createPublicClient, http } from 'viem';
import { baseSepolia } from 'viem/chains';

const client = createPublicClient({
  chain: baseSepolia,
  transport: http('https://base-sepolia.api.onfinality.io/public'),
});

const blockNumber = await client.getBlockNumber();
console.log('Base Sepolia head:', blockNumber);

If getBlockNumber returns a number that keeps increasing, your read path works. The next thing to test is a write path: deploy a trivial contract or send a small transfer, then confirm the transaction on the explorer.

Debugging common Base Sepolia failures

Most Base Sepolia problems fall into a small number of categories. Match the symptom to the likely cause before you change code.

Two of these deserve more detail. First, nonce gaps: if you send two transactions quickly and the first fails, the second can sit pending because the nonce is out of order. Resetting the account nonce in your wallet, or sending a replacement transaction with the same nonce and a higher fee, usually clears it. Second, eth_getLogs: public endpoints often cap the block range or the number of results. If you are indexing, request smaller windows and paginate, or use an endpoint that explicitly supports archive queries.

What changes when you move to Base mainnet

The good news is that Base Sepolia and Base mainnet share the same architecture, so migration is mostly configuration. The chain ID changes from 84532 to 8453, the explorer changes from sepolia.basescan.org to basescan.org, and the ETH becomes real.

What does not change is the shape of your infrastructure decision. If you were relying on a shared public endpoint on testnet and it held up, that is not evidence it will hold up on mainnet under real traffic. Treat the move to mainnet as a good moment to review your RPC provider choice and confirm your endpoint supports the methods you actually call, including any archive or trace methods. OnFinality lists both Base and Base Sepolia as supported networks, so you can keep the same provider across environments.

Operational checklist before you ship

A short list that catches most testnet-to-production surprises:

1. Confirm the endpoint responds to eth_chainId with 0x14a34.
2. Store the RPC URL in environment variables, not in source code.
3. Decide whether you need archive data or WebSocket, and pick an endpoint that supports it.
4. Add a fallback endpoint so a single provider outage does not stop your pipeline.
5. Log the chain ID your app connects to at startup, so a misconfigured environment is obvious.
6. Keep testnet and mainnet configuration separate and clearly named.
7. Review RPC pricing before you scale request volume, so there are no surprises.

Key Takeaways

• Base Sepolia uses chain ID 84532, currency ETH, and explorer https://sepolia.basescan.org.
• The OnFinality public endpoint is https://base-sepolia.api.onfinality.io/public over HTTP.
• Public endpoints are fine for manual testing but a poor fit for CI, staging, or anything needing archive or WebSocket access.
• Verify connectivity with eth_chainId before debugging application code.
• Most failures map to wrong chain ID, nonce gaps, missing testnet ETH, or shared-endpoint limits.
• Migration to Base mainnet is mostly configuration, but it is a good time to re-evaluate your RPC setup.

Frequently Asked Questions

What is the Base Sepolia chain ID?

Base Sepolia uses chain ID 84532, which is 0x14a34 in hex. Base mainnet uses 8453.

What is the Base Sepolia RPC URL?

The OnFinality public endpoint is https://base-sepolia.api.onfinality.io/public. You can also browse supported RPC networks to see other options.

Is the Base Sepolia public endpoint rate limited?

Public endpoints are shared, so throughput is not guaranteed and heavy or bursty usage can be throttled. For predictable capacity, use a managed RPC API or a dedicated node.

How do I get Base Sepolia ETH?

Use a Base Sepolia faucet, or bridge testnet ETH from Ethereum Sepolia. Faucet availability changes, so check current options before relying on one.

Does Base Sepolia support WebSocket subscriptions?

The public OnFinality endpoint is HTTP. If you need eth_subscribe for new blocks or pending transactions, use an endpoint that supports WebSocket transport.

Can I use the same code on Base mainnet?

Yes. The JSON-RPC methods and EVM behavior are the same. You change the chain ID, explorer, and RPC URL, and you use real ETH.