Quick answer: “tx fee (X ether) exceeds the configured cap (1.00 ether)” means the RPC node refused your transaction because gas limit × gas price (or × maxFeePerGas for EIP-1559 transactions) works out to more than 1 CORE. It’s a safety limit on the RPC node, not on the Core network itself. To fix it, lower the gas limit, lower the max fee, or split the job into smaller transactions. With Core’s 60 gwei minimum gas price, that means a single transaction sent through the public RPC can use at most about 16.67 million gas.
Developers hit this error most often when they deploy large contracts, run batch mints or airdrops, or hardcode a huge gas value in a Hardhat or script config. Below we explain where the limit comes from, show the numbers we got from live tests against Core’s public RPC endpoints on November 17, 2026, and walk through the fixes.
What the error actually means
Core’s node software (core-chain, a fork of Geth) has a setting called RPCTxFeeCap. In the v1.0.27 source code its default value is 1 (1 ether, which on Core means 1 CORE). Each node operator can change it with the --rpc.txfeecap flag (0 = no cap). The Geth documentation describes the same flag.
Before a node accepts a transaction over RPC, it runs a checkTxFee function. The function multiplies the transaction’s gas price by its gas limit, converts the result to whole coins, and rejects the transaction if the total is above the cap:
tx fee (3.00 ether) exceeds the configured cap (1.00 ether)
Three details catch people out:
- It’s based on the worst case, not on what you actually pay. The check uses your full gas limit and your maximum price, even if the transaction would only burn a fraction of that.
- The word “ether” is just Geth’s label. On Core the amount is in CORE.
- It happens before every other check. Your balance, nonce and the 60 gwei minimum are not looked at yet. An empty wallet gets the same error.
What we measured on Core’s public RPCs (Nov 17, 2026)
We signed throwaway transactions from a new, unfunded address (chain ID 1116) and sent them with eth_sendRawTransaction to rpc.coredao.org, rpc.ankr.com/core and core.drpc.org. Because the wallet had no balance, any transaction that got past the fee cap failed with “insufficient funds”. That makes it easy to see where the cap kicks in. The node reported Geth/v1.0.27, and the latest blocks had a gas limit of 50,000,000.
| Gas limit | Gas price | Max fee | Result |
|---|---|---|---|
| 16,666,666 | 60 gwei | 0.99999996 CORE | Passed the cap (then “insufficient funds”) |
| 16,666,667 | 60 gwei | 1.00000002 CORE | “tx fee (1.00 ether) exceeds the configured cap” |
| 10,000,000 | 100 gwei | Exactly 1 CORE | Passed the cap (exactly 1 CORE is allowed) |
| 50,000,000 | 60 gwei | 3 CORE | “tx fee (3.00 ether) exceeds the configured cap” |
| 50,000,001 | 1 gwei | 0.05 CORE | “exceeds block gas limit” |
On Ankr we got exactly the same messages. On dRPC, transactions under the cap returned the same messages too. For the two over-cap cases (16,666,667 gas at 60 gwei and 50,000,001 gas at 20 gwei), though, dRPC returned an HTTP 500 “Temporary internal error” instead of the readable message. If you use dRPC and keep getting vague 500 errors on big transactions, check the fee cap first. Legacy and EIP-1559 (type 2) transactions behaved the same way. For type 2 transactions, the node uses maxFeePerGas in the calculation.

Why ~16.67M gas is the practical ceiling on Core
Core’s public RPC rejects gas prices below 60 gwei (we covered that in our transaction underpriced on Core guide). Put that together with the 1 CORE cap and you get a hard ceiling of 1 CORE ÷ 60 gwei = 16,666,666 gas per transaction. The 50M block gas limit only matters if you send through a node with a raised or disabled cap. The higher your gas price, the lower the ceiling:
| Max gas price | Highest gas limit under a 1 CORE cap |
|---|---|
| 60 gwei | 16,666,666 |
| 80 gwei | 12,500,000 |
| 100 gwei | 10,000,000 |
| 200 gwei | 5,000,000 |
How to fix “exceeds the configured cap” on Core
1. Stop hardcoding a giant gas limit
This is the most common cause. A config such as gas: 30000000 or a script that always sends gasLimit: 50_000_000 fails at any valid Core gas price. In Hardhat, the network gas option defaults to "auto", which estimates the gas limit for each transaction. Go back to "auto", or set a realistic number based on eth_estimateGas plus a modest buffer (Hardhat’s gasMultiplier, for example 1.2).
core: {
url: "https://rpc.coredao.org",
chainId: 1116,
gas: "auto",
gasMultiplier: 1.2,
gasPrice: 60000000000 // 60 gwei
}
2. Lower the max fee, not just the tip
The node checks your maximum price. Some tools set maxFeePerGas to a multiple of the current price, which can push a large transaction over 1 CORE even when the real fee would be lower. On Core, recent blocks reported a base fee of 0, so a max fee close to the 60 gwei minimum is usually enough. Don’t go below 60 gwei, or the RPC will return “transaction underpriced” instead.
3. Split big jobs into batches
If a single airdrop, mint or migration call genuinely needs more than ~16M gas, break it into several transactions (for example, 200 recipients per call instead of 2,000). This also limits how much you lose if one batch reverts. Our gas required exceeds allowance guide explains how to read eth_estimateGas failures when you size batches.
4. Shrink the deployment
Large contract deployments can come close to the ceiling. Turning on the Solidity optimizer, moving logic into libraries, or deploying modules separately all reduce the gas a single deployment transaction needs.
5. Use a node with a higher cap (advanced)
The cap is a per-node RPC setting. If you run your own Core full node, you can start it with --rpc.txfeecap set to a higher value, or 0 to remove the cap. The cap does not lift the protocol limits: the gas limit must still be at or below the current block gas limit (50,000,000 in our test), and you still need enough CORE to cover gas × price. If you go this route, set your own sanity checks in your scripts, because the cap exists to stop you from accidentally sending a transaction with an absurd fee.
Related errors you may see next
- “exceeds block gas limit”: your gas limit is above 50,000,000. You’ll only see this when the fee is under the cap, for example with a gas price below 60 gwei on a test node.
- “insufficient funds for gas * price + value”: you passed the cap, but your wallet can’t cover the worst-case cost. See our insufficient funds for gas fix.
- “intrinsic gas too low”: you went too far the other way and set the gas limit below the minimum. See intrinsic gas too low.
FAQ
Does this cap mean I’ll be charged 1 CORE?
No. The cap is a pre-check on the worst-case fee (gas limit × max price). You pay for the gas your transaction actually uses at the effective price, and that can be far lower.
Can I change the cap from ethers.js, web3.js or MetaMask?
No. The limit is enforced by the RPC node you send to. Your code can only change the gas limit and fee fields so the product stays at or below 1 CORE.
Is the 1 CORE cap the same on every Core RPC?
On November 17, 2026, rpc.coredao.org and Ankr returned the 1.00 cap, and dRPC rejected the same over-cap transactions (with an HTTP 500 error). Other providers or private nodes may use different settings.
Does Core testnet have the same limit?
The default in core-chain is the same, but we could not reach the testnet RPC during this test, so check it yourself with a small over-cap transaction before you rely on it.
Disclaimer: This article is for educational purposes only and is not financial or investment advice. Always test transactions with small amounts first, and double-check network settings before sending funds.
