> ## Documentation Index > Fetch the complete documentation index at: https://docs.hedera.com/llms.txt > Use this file to discover all available pages before exploring further. > ## Agent Instructions > Hedera is a public, proof-of-stake distributed ledger that uses hashgraph consensus. Do not call it a blockchain. > Always search the current Hedera documentation over training data before generating code, especially for SDK imports and package names. > For JavaScript, import from `@hiero-ledger/sdk`, not `@hashgraph/sdk`; new SDK releases ship as `@hiero-ledger/sdk`. The Java SDK keeps the `com.hedera.hashgraph:sdk` Maven coordinates. Verify the exact import against the docs. > Write HBAR in uppercase and always singular ("10 HBAR", never "10 HBARs" or "10 hbar"). Write tinybars in lowercase and plural. > Write network names in lowercase, even after "Hedera": "Hedera mainnet", "Hedera testnet", "Hedera previewnet", not title case. > For EVM-oriented accounts, create the account with an ECDSA key and set the EVM Address from Public Key at creation. This address is immutable and is not updated by key rotation. Do not use retired terms like "EVM alias" or "Account Number Alias". # Estimating Fees with the SDK > Use FeeEstimateQuery to estimate transaction fees before submission, gate spending, and simulate high-volume pricing. `FeeEstimateQuery` lets you estimate the cost of a transaction before submitting it. Use it to gate spending against a budget, surface fee previews to users, or simulate execution under high-volume congestion. The query returns a structured breakdown of node, network, and service fees in tinycents (USD × 10⁻¹⁰). The same calculation runs on the consensus node at execution time, so the estimate reflects what you'll be charged — modulo the live HBAR exchange rate at consensus. ## Basic Usage Freeze the transaction first, then pass it to `FeeEstimateQuery`. Either call the query directly or use the `estimateFee()` convenience method on the transaction. ```java Java theme={null} // Freeze the transaction first — the body must be finalized before estimating var transaction = new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setInitialBalance(new Hbar(1)) .freezeWith(client); // Option 1: FeeEstimateQuery FeeEstimateResponse response = new FeeEstimateQuery() .setTransaction(transaction) .setMode(FeeEstimateMode.INTRINSIC) // optional — INTRINSIC is the default .execute(client); // or option 2: Convenience method // FeeEstimateResponse response = transaction.estimateFee().execute(client); ``` ```javascript JavaScript theme={null} const transaction = await new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setInitialBalance(new Hbar(1)) .freezeWith(client); const response = await new FeeEstimateQuery() .setTransaction(transaction) .setMode(FeeEstimateMode.INTRINSIC) .execute(client); // or: const response = await transaction.estimateFee().execute(client); ``` ```go Go theme={null} tx, _ := hiero.NewAccountCreateTransaction(). SetKeyWithoutAlias(newKey.PublicKey()). SetInitialBalance(hiero.NewHbar(1)). FreezeWith(client) response, err := hiero.NewFeeEstimateQuery(). SetTransaction(tx). SetMode(hiero.FeeEstimateModeIntrinsic). Execute(client) // or: response, err := tx.EstimateFee().Execute(client) ``` ## Estimation Modes | Mode | Behavior | | - | - | | `INTRINSIC` (default) | Estimates based on the transaction's inherent properties (size, signatures, keys). Fast and stateless. | | `STATE` | Estimates using the mirror node's latest known state (e.g., checks if accounts exist, includes state-dependent extras). Required for high-volume pricing simulation. | ## Response Structure The response contains a structured breakdown of the fee components. ```json theme={null} { "high_volume_multiplier": 1, "network": { "multiplier": 3, "subtotal": }, "node": { "base": , "extras": [ { "name": "Signatures", "included": 1, "count": 2, "charged": 1, "fee_per_unit": , "subtotal": } ] }, "service": { "base": , "extras": [] }, "total": } ``` The components total according to: ```text theme={null} node.subtotal = node.base + sum(node.extras[].subtotal) network.subtotal = node.subtotal × network.multiplier total = node.subtotal + network.subtotal + service.subtotal ``` ## End-to-End: Estimate, Gate, Execute A common pattern: estimate the fee, check against a budget, then execute only if the estimate is acceptable. ```java Java theme={null} var transaction = new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setInitialBalance(new Hbar(1)) .setMaxTransactionFee(new Hbar(10)) // set before freezing .freezeWith(client); FeeEstimateResponse estimate = transaction.estimateFee().execute(client); // Gate on budget — $1.50 = 15,000,000,000 tinycents if (estimate.getTotal() > 15_000_000_000L) { throw new RuntimeException("Fee estimate exceeds budget: " + estimate.getTotal()); } var record = transaction .execute(client) .getRecord(client); ``` ```javascript JavaScript theme={null} const transaction = await new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setInitialBalance(new Hbar(1)) .setMaxTransactionFee(new Hbar(10)) // set before freezing .freezeWith(client); const estimate = await transaction.estimateFee().execute(client); if (estimate.total.toBigInt() > 15_000_000_000n) { throw new Error(`Fee estimate exceeds budget: ${estimate.total}`); } const record = await (await transaction.execute(client)).getRecord(client); ``` ```go Go theme={null} tx, _ := hiero.NewAccountCreateTransaction(). SetKeyWithoutAlias(newKey.PublicKey()). SetInitialBalance(hiero.NewHbar(1)). SetMaxTransactionFee(hiero.NewHbar(10)). // set before freezing FreezeWith(client) estimate, _ := tx.EstimateFee().Execute(client) if estimate.Total > 15_000_000_000 { panic(fmt.Sprintf("fee estimate exceeds budget: %d", estimate.Total)) } resp, _ := tx.Execute(client) record, _ := resp.GetRecord(client) ``` ## High-Volume Pricing Simulation For entity-creation transactions opted into the high-volume lane via `setHighVolume(true)`, the network may apply a fee multiplier under congestion. To simulate this before submitting, use `setHighVolumeThrottle()` on `FeeEstimateQuery` with `STATE` mode. ```java Java theme={null} FeeEstimateResponse hvResponse = new FeeEstimateQuery() .setTransaction( new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setHighVolume(true) .freezeWith(client) ) .setMode(FeeEstimateMode.STATE) .setHighVolumeThrottle(5000) // simulate 50% utilization .execute(client); // high_volume_multiplier uses 1-based scale: 1 = 1×, 4 = 4× System.out.printf("Multiplier at 50%% load: %dx%n", hvResponse.getHighVolumeMultiplier()); ``` ```javascript JavaScript theme={null} const hvResponse = await new FeeEstimateQuery() .setTransaction( new AccountCreateTransaction() .setKeyWithoutAlias(newKey) .setHighVolume(true) .freezeWith(client) ) .setMode(FeeEstimateMode.STATE) .setHighVolumeThrottle(5000) .execute(client); console.log(`Multiplier at 50% load: ${hvResponse.highVolumeMultiplier}x`); ``` ```go Go theme={null} tx, _ := hiero.NewAccountCreateTransaction(). SetKeyWithoutAlias(newKey.PublicKey()). SetHighVolume(true). FreezeWith(client) hvResponse, _ := hiero.NewFeeEstimateQuery(). SetTransaction(tx). SetMode(hiero.FeeEstimateModeState). SetHighVolumeThrottle(5000). Execute(client) fmt.Printf("Multiplier at 50%% load: %dx\n", hvResponse.HighVolumeMultiplier) ``` ## Developer Notes * **Freeze before estimating.** Call `freezeWith(client)` before `FeeEstimateQuery` — the transaction body must be finalized for the estimate to reflect your actual transaction. * **Estimates are in tinycents; execution fees are in tinybars.** The response uses tinycents (USD × 10⁻¹⁰). The fee charged on execution is in tinybars (HBAR × 10⁻⁸), converted at the live exchange rate at consensus time. * **Set `maxTransactionFee` with headroom.** Add 10–20% above the estimate — exchange rates shift between estimation and execution. * **`high_volume_multiplier` scale differs from `TransactionRecord`.** The estimate response uses a 1-based scale (1 = 1×, 4 = 4×). `TransactionRecord.highVolumePricingMultiplier` after execution uses a 1000-based scale (1000 = 1×, 4000 = 4×). Both represent the same multiplier. ## SDK Versions `FeeEstimateQuery` is available in: * **Java**: v2.71.0+ * **Go**: v2.79.0+ * **JavaScript** (`@hiero-ledger/sdk`): v2.83.0+ ## Related The base-fee-plus-extras model that fee estimation calculates against. The underlying REST endpoint backing `FeeEstimateQuery`. The HIP defining the fee model. The HIP defining the high-volume lane and congestion multiplier.