# eth\_getBalance - TRON

## Description

The 'eth\_getBalance' method in the Tron protocol's Web3 interface is a crucial RPC protocol function designed for developers to retrieve the balance of a specified account address. By using the JSON-RPC API Interface, 'eth\_getBalance' allows users to query the current balance of an account at a particular block height, offering flexibility and precision. This method requires two parameters: the address of the account and the block number or state (such as 'latest', 'earliest', or 'pending'). The response is the balance in Wei, expressed as a hexadecimal value. This function is essential for applications that need to monitor account balances, manage transactions, or perform financial analytics within the Tron ecosystem. Its efficient design ensures quick and reliable access to account data.

## Supported Networks

The eth\_getBalance RPC method supports the following network types

* **Mainnet**
* **Testnets**

## Parameters

Here is the list of parameters eth\_getBalance method needs to be executed.

* **Parameter 1:**
  * **Type:** String
  * **Description:** The address of the account whose balance is being queried.
  * **Requirement:** Required
  * **Example:** "0x41f0cc5a2a84cd0f68ed1667070934542d673acbd8"
* **Parameter 2:**
  * **Type:** String
  * **Description:** The block number, or the string "latest", "earliest", or "pending", to specify the state of the blockchain for which the balance is queried.
  * **Requirement:** Required
  * **Default/Supported Values:** "latest", "earliest", "pending", or a specific block number (e.g., "0x10d4f" for block 68623)

### URL

```json
https://go.getblock.io/<ACCESS-TOKEN>/
```

Here’s a sample cURL request using eth\_getBalance

Request

```json
curl --location --request POST 'https://go.getblock.io/<ACCESS-TOKEN>/jsonrpc' 
--header 'Content-Type: application/json' 
{"jsonrpc": "2.0", "method": "eth_getBalance", "params": ["0x41f0cc5a2a84cd0f68ed1667070934542d673acbd8", "latest"], "id": "getblock.io"}
```

Response

```json

{
  "jsonrpc": "2.0",
  "id": "getblock.io",
  "result": "0x680a6604"
}
```

## Body Parameters

Here is the list of body parameters for the `eth_getBalance` method:

1. **jsonrpc**: This parameter specifies the version of the JSON-RPC protocol being used. In this case, it is "2.0".
2. **id**: This is an identifier for the request. It can be any string or number, and it helps match responses to requests. Here, it is set to "getblock.io".
3. **result**: This parameter contains the balance of the account in hexadecimal format. In the provided response, the balance is "0x680a6604".

## Use Case

Here are some use-cases for the `eth_getBalance` method in Web3 programming:

1. **Wallet Balance Display**: One of the most common use cases for the `eth_getBalance` method is to display the Ether balance of a user's wallet in a decentralized application (dApp). By retrieving the balance of a specific Ethereum address, developers can show users how much Ether they have in their wallet, enabling them to make informed decisions about transactions, investments, or other interactions within the dApp.
2. **Transaction Validation**: Before executing a transaction, developers can use the `eth_getBalance` method to ensure that a wallet has sufficient funds. This is crucial for preventing failed transactions due to insufficient balance. By checking the balance prior to initiating a transaction, the application can alert the user if their balance is too low, thereby improving the user experience and reducing transaction errors.
3. **Automated Financial Reporting**: For applications that require regular financial reporting or auditing, the `eth_getBalance` method can be used to automate the process of recording account balances at specific intervals. This is particularly useful for businesses or individuals who need to track their Ethereum holdings over time for accounting, tax purposes, or portfolio management. By periodically retrieving and storing balance data, developers can generate comprehensive financial reports with ease.

## Code for eth\_getBalance

```python
import requests
import json

url = "https://go.getblock.io/<ACCESS-TOKEN>/"
headers = {
    "Content-Type": "application/json"
}
payload = {"jsonrpc": "2.0", "method": "eth_getBalance", "params": ["0x41f0cc5a2a84cd0f68ed1667070934542d673acbd8", "latest"], "id": "getblock.io"}

response = requests.post(url, headers=headers, data=json.dumps(payload))

# Check the response and print the result
if response.status_code == 200:
    print("Result:", response.json().get("result"))
else:
    print("Error:", response.status_code, response.text)
```

## Common Errors

Common Errors\
When using the eth\_getBalance RPC Tron method, the following issues may occur:

* Incorrect Address Format: If the address is not in the correct format, the method will fail. Ensure the address is a valid hexadecimal Ethereum address starting with '0x'.
* Network Mismatch: The specified address might not exist on the network you're querying. Verify that you are connected to the correct Tron network and that the address is valid on that network.
* Outdated Block Parameter: Using a non-existent block parameter instead of "latest" can result in errors. Always use "latest" for the most recent balance unless you have a specific block in mind.
* Insufficient Node Permissions: If the node you are querying does not allow access to balance information, you may encounter permission errors. Check your node's permissions and ensure you have the necessary access rights.

The eth\_getBalance method is essential in Web3 applications as it provides real-time balance data for any account on the Tron network. This allows developers to create responsive and dynamic applications that can react to changes in account balances, enhancing user experience and enabling more sophisticated financial interactions.

### conclusion

The `eth_getBalance` RPC method is a crucial tool for retrieving the balance of an Ethereum account, specified by its address, at a particular block. This method provides users with the ability to check account balances in real-time, using the "latest" parameter to get the most current data. While `eth_getBalance` is specific to Ethereum, similar functionalities are available in other blockchain networks like Tron, allowing users to manage and verify account balances across different platforms.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.getblock.io/api-reference/tron-trx/json-rpc_api/eth_getbalance.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.