> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getpara.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Query Wallet Balances

> Check ETH and ERC-20 token balances using Web3 libraries with Para

Query ETH and ERC-20 token balances for Para wallets across different networks.

## Prerequisites

You need Web3 libraries configured with Para authentication.

<Card title="Setup Web3 Libraries" description="Configure Ethers.js, Viem, or Wagmi with Para before proceeding" href="/v3/react/guides/web3-operations/evm/setup-libraries" />

<Tabs>
  <Tab title="Ethers.js">
    ## Query ETH Balance

    ```typescript theme={null}
    import { ethers } from "ethers";
    import { ParaEthersSigner } from "@getpara/ethers-v6-integration";

    async function getETHBalance(signer: ParaEthersSigner, provider: ethers.Provider) {
      const address = await signer.getAddress();
      const balance = await provider.getBalance(address);

      const formattedBalance = ethers.formatEther(balance);
      console.log(`ETH Balance: ${formattedBalance} ETH`);

      return {
        wei: balance.toString(),
        ether: formattedBalance
      };
    }
    ```

    ## Query ERC-20 Token Balance

    ```typescript theme={null}
    import { ethers } from "ethers";

    const ERC20_ABI = [
      "function balanceOf(address owner) view returns (uint256)",
      "function decimals() view returns (uint8)",
      "function symbol() view returns (string)"
    ];

    async function getTokenBalance(
      signer: any,
      tokenAddress: string,
      provider: ethers.Provider
    ) {
      const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
      const address = await signer.getAddress();

      const [balance, decimals, symbol] = await Promise.all([
        contract.balanceOf(address),
        contract.decimals(),
        contract.symbol()
      ]);

      const formattedBalance = ethers.formatUnits(balance, decimals);
      console.log(`${symbol} Balance: ${formattedBalance}`);

      return {
        raw: balance.toString(),
        formatted: formattedBalance,
        symbol,
        decimals
      };
    }
    ```
  </Tab>

  <Tab title="Viem">
    ## Query ETH Balance

    ```typescript theme={null}
    import { formatEther } from "viem";
    import { useParaViemAccount } from "@getpara/react-sdk";

    function useETHBalance(publicClient: any) {
      const { viemAccount } = useParaViemAccount();

      const getETHBalance = async () => {
        if (!viemAccount) return;
        const balance = await publicClient.getBalance({
          address: viemAccount.address
        });

        const formattedBalance = formatEther(balance);
        console.log(`ETH Balance: ${formattedBalance} ETH`);

        return {
          wei: balance.toString(),
          ether: formattedBalance
        };
      };

      return { getETHBalance };
    }
    ```

    ## Query ERC-20 Token Balance

    ```typescript theme={null}
    import { formatUnits } from "viem";

    const ERC20_ABI = [
      {
        name: "balanceOf",
        type: "function",
        stateMutability: "view",
        inputs: [{ name: "owner", type: "address" }],
        outputs: [{ type: "uint256" }]
      },
      {
        name: "decimals",
        type: "function",
        stateMutability: "view",
        inputs: [],
        outputs: [{ type: "uint8" }]
      },
      {
        name: "symbol",
        type: "function",
        stateMutability: "view",
        inputs: [],
        outputs: [{ type: "string" }]
      }
    ] as const;

    async function getTokenBalance(
      publicClient: any,
      account: any,
      tokenAddress: `0x${string}`
    ) {
      const [balance, decimals, symbol] = await Promise.all([
        publicClient.readContract({
          address: tokenAddress,
          abi: ERC20_ABI,
          functionName: "balanceOf",
          args: [account.address]
        }),
        publicClient.readContract({
          address: tokenAddress,
          abi: ERC20_ABI,
          functionName: "decimals"
        }),
        publicClient.readContract({
          address: tokenAddress,
          abi: ERC20_ABI,
          functionName: "symbol"
        })
      ]);

      const formattedBalance = formatUnits(balance, decimals);
      console.log(`${symbol} Balance: ${formattedBalance}`);

      return {
        raw: balance.toString(),
        formatted: formattedBalance,
        symbol,
        decimals
      };
    }
    ```
  </Tab>

  <Tab title="Wagmi">
    ## Query ETH Balance

    ```typescript theme={null}
    import { useBalance, useAccount } from "@getpara/react-sdk/wagmi";

    function ETHBalance() {
      const { address } = useAccount();
      const { data, isError, isLoading } = useBalance({
        address: address
      });

      if (isLoading) return <div>Loading balance...</div>;
      if (isError) return <div>Error fetching balance</div>;

      return (
        <div>
          <p>ETH Balance: {data?.formatted} {data?.symbol}</p>
          <p>Wei: {data?.value.toString()}</p>
        </div>
      );
    }
    ```

    ## Query ERC-20 Token Balance

    ```typescript theme={null}
    import { useAccount, useReadContracts } from "@getpara/react-sdk/wagmi";

    const ERC20_ABI = [
      {
        name: "balanceOf",
        type: "function",
        stateMutability: "view",
        inputs: [{ name: "owner", type: "address" }],
        outputs: [{ type: "uint256" }]
      },
      {
        name: "decimals",
        type: "function",
        stateMutability: "view",
        inputs: [],
        outputs: [{ type: "uint8" }]
      },
      {
        name: "symbol",
        type: "function",
        stateMutability: "view",
        inputs: [],
        outputs: [{ type: "string" }]
      }
    ] as const;

    function TokenBalance({ tokenAddress }: { tokenAddress: `0x${string}` }) {
      const { address } = useAccount();

      const { data, isLoading } = useReadContracts({
        contracts: [
          {
            address: tokenAddress,
            abi: ERC20_ABI,
            functionName: "balanceOf",
            args: [address!]
          },
          {
            address: tokenAddress,
            abi: ERC20_ABI,
            functionName: "decimals"
          },
          {
            address: tokenAddress,
            abi: ERC20_ABI,
            functionName: "symbol"
          }
        ]
      });

      if (isLoading) return <div>Loading token balance...</div>;

      const balance = data?.[0]?.result;
      const decimals = data?.[1]?.result;
      const symbol = data?.[2]?.result;

      if (!balance || !decimals) return <div>No balance data</div>;

      const formatted = (Number(balance) / 10 ** decimals).toFixed(4);

      return (
        <div>
          <p>{symbol} Balance: {formatted}</p>
        </div>
      );
    }
    ```
  </Tab>
</Tabs>

## Next Steps

<CardGroup cols={3}>
  <Card title="Send Tokens" description="Transfer ETH and ERC-20 tokens to other addresses" href="/v3/react/guides/web3-operations/evm/send-tokens" icon="paper-plane" />

  <Card title="Estimate Gas" description="Calculate gas costs before sending transactions" href="/v3/react/guides/web3-operations/evm/estimate-gas" icon="gas-pump" />

  <Card title="Manage Allowances" description="Check and set token spending approvals" href="/v3/react/guides/web3-operations/evm/manage-allowances" icon="shield-check" />
</CardGroup>