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

# Check wallet balance

> Get SOL and token balances for the connected wallet

Check the SOL balance and SPL token balances for the connected wallet using the Phantom SDK.

<Tabs>
  <Tab title="React">
    ```tsx theme={null}
    import { useSolana, useAccounts } from "@phantom/react-sdk";
    import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
    import { getAssociatedTokenAddress, getAccount } from "@solana/spl-token";
    import { useEffect, useState } from "react";

    function WalletBalance() {
      const { solana } = useSolana();
      const addresses = useAccounts();
      const [solBalance, setSolBalance] = useState<number | null>(null);
      const [loading, setLoading] = useState(false);

      const checkBalance = async () => {
        if (!addresses?.[0]) return;

        setLoading(true);
        try {
          const connection = new Connection("https://api.mainnet-beta.solana.com");
          const publicKey = new PublicKey(addresses[0].address);

          // Get SOL balance
          const balance = await connection.getBalance(publicKey);
          setSolBalance(balance / LAMPORTS_PER_SOL);
        } catch (error) {
          console.error("Failed to fetch balance:", error);
        } finally {
          setLoading(false);
        }
      };

      useEffect(() => {
        if (addresses?.[0]) {
          checkBalance();
        }
      }, [addresses]);

      if (!addresses?.[0]) {
        return <div>Please connect your wallet</div>;
      }

      return (
        <div>
          <h2>Wallet Balance</h2>
          <p>Address: {addresses[0].address}</p>
          {loading ? (
            <p>Loading balance...</p>
          ) : (
            <p>SOL Balance: {solBalance?.toFixed(4) ?? "0.0000"} SOL</p>
          )}
          <button onClick={checkBalance}>Refresh Balance</button>
        </div>
      );
    }
    ```
  </Tab>

  <Tab title="Browser SDK">
    ```typescript theme={null}
    import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
    import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";

    const sdk = new BrowserSDK({
      providers: ["google", "apple", "injected"],
      appId: "your-app-id",
      addressTypes: [AddressType.solana],
    });

    async function getWalletBalance() {
      if (!sdk.solana.isConnected()) {
        await sdk.connect({ provider: "google" });
      }

      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(await sdk.solana.getPublicKey());

      // Get SOL balance
      const balance = await connection.getBalance(publicKey);
      const solBalance = balance / LAMPORTS_PER_SOL;

      return {
        address: publicKey.toString(),
        solBalance,
        lamports: balance,
      };
    }

    // Usage
    const balance = await getWalletBalance();
    console.log(`${balance.solBalance} SOL`);
    ```
  </Tab>

  <Tab title="React Native">
    ```tsx theme={null}
    import { useSolana, useAccounts } from "@phantom/react-native-sdk";
    import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
    import { View, Text, Button, StyleSheet, ActivityIndicator } from "react-native";
    import { useEffect, useState } from "react";

    function WalletBalance() {
      const { solana } = useSolana();
      const addresses = useAccounts();
      const [solBalance, setSolBalance] = useState<number | null>(null);
      const [loading, setLoading] = useState(false);

      const checkBalance = async () => {
        if (!addresses?.[0]) return;

        setLoading(true);
        try {
          const connection = new Connection("https://api.mainnet-beta.solana.com");
          const publicKey = new PublicKey(addresses[0].address);

          const balance = await connection.getBalance(publicKey);
          setSolBalance(balance / LAMPORTS_PER_SOL);
        } catch (error) {
          console.error("Failed to fetch balance:", error);
        } finally {
          setLoading(false);
        }
      };

      useEffect(() => {
        if (addresses?.[0]) {
          checkBalance();
        }
      }, [addresses]);

      if (!addresses?.[0]) {
        return (
          <View style={styles.container}>
            <Text>Please connect your wallet</Text>
          </View>
        );
      }

      return (
        <View style={styles.container}>
          <Text style={styles.title}>Wallet Balance</Text>
          <Text style={styles.address}>{addresses[0].address}</Text>
          {loading ? (
            <ActivityIndicator size="large" style={styles.loader} />
          ) : (
            <Text style={styles.balance}>
              {solBalance?.toFixed(4) ?? "0.0000"} SOL
            </Text>
          )}
          <Button title="Refresh Balance" onPress={checkBalance} />
        </View>
      );
    }

    const styles = StyleSheet.create({
      container: {
        flex: 1,
        padding: 20,
        justifyContent: "center",
      },
      title: {
        fontSize: 24,
        fontWeight: "bold",
        marginBottom: 10,
      },
      address: {
        fontSize: 14,
        color: "#666",
        marginBottom: 20,
      },
      balance: {
        fontSize: 32,
        fontWeight: "bold",
        marginBottom: 20,
      },
      loader: {
        marginVertical: 20,
      },
    });
    ```
  </Tab>
</Tabs>

## Get token balances

Check balances for specific SPL tokens:

<Tabs>
  <Tab title="React">
    ```tsx theme={null}
    import { useSolana, useAccounts } from "@phantom/react-sdk";
    import { Connection, PublicKey } from "@solana/web3.js";
    import { getAssociatedTokenAddress, getAccount, getMint } from "@solana/spl-token";
    import { useState } from "react";

    const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

    function TokenBalance() {
      const { solana } = useSolana();
      const addresses = useAccounts();
      const [tokenBalance, setTokenBalance] = useState<string | null>(null);

      const checkTokenBalance = async () => {
        if (!addresses?.[0]) return;

        try {
          const connection = new Connection("https://api.mainnet-beta.solana.com");
          const publicKey = new PublicKey(addresses[0].address);

          // Get associated token account
          const tokenAccount = await getAssociatedTokenAddress(USDC_MINT, publicKey);

          // Get token account info
          const accountInfo = await getAccount(connection, tokenAccount);
          
          // Get mint info to get decimals
          const mintInfo = await getMint(connection, USDC_MINT);
          
          // Calculate balance with decimals
          const balance = Number(accountInfo.amount) / 10 ** mintInfo.decimals;
          setTokenBalance(balance.toFixed(mintInfo.decimals));
        } catch (error) {
          // Token account doesn't exist
          setTokenBalance("0");
        }
      };

      return (
        <div>
          <button onClick={checkTokenBalance}>Check USDC Balance</button>
          {tokenBalance !== null && <p>USDC Balance: {tokenBalance}</p>}
        </div>
      );
    }
    ```
  </Tab>

  <Tab title="Browser SDK">
    ```typescript theme={null}
    import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
    import { Connection, PublicKey } from "@solana/web3.js";
    import { getAssociatedTokenAddress, getAccount, getMint } from "@solana/spl-token";

    const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");

    const sdk = new BrowserSDK({
      providers: ["google", "apple", "injected"],
      appId: "your-app-id",
      addressTypes: [AddressType.solana],
    });

    async function getTokenBalance(mintAddress: PublicKey) {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const publicKey = new PublicKey(await sdk.solana.getPublicKey());

      try {
        const tokenAccount = await getAssociatedTokenAddress(mintAddress, publicKey);
        const accountInfo = await getAccount(connection, tokenAccount);
        const mintInfo = await getMint(connection, mintAddress);
        
        const balance = Number(accountInfo.amount) / 10 ** mintInfo.decimals;
        return balance;
      } catch {
        return 0; // Token account doesn't exist
      }
    }

    // Usage
    const usdcBalance = await getTokenBalance(USDC_MINT);
    console.log(`USDC Balance: ${usdcBalance}`);
    ```
  </Tab>
</Tabs>