mkdir tonweb-project
cd tonweb-project
npm init -y

npm install tonweb

// For ES Module
// import TonWeb from "tonweb";

// For CommonJS
const TonWeb = require('tonweb'); 

const rpcEndpoint = "YOUR_CHAINSTACK_RPC_ENDPOINT";
const tonweb = new TonWeb(new TonWeb.HttpProvider(rpcEndpoint));

tonweb.getBalance('EQ...').then(info => {
	console.log(info);
});

mkdir ton-project
cd ton-project
npm init -y

npm install ton

// For ES Module
// import { TonClient } from 'ton';

// For CommonJS
const { TonClient } = require('ton');

const rpcEndpoint = "YOUR_CHAINSTACK_RPC_ENDPOINT";
const tonClient = new TonClient({
  endpoint: rpcEndpoint
});

tonClient.getBalance('EQ...').then(info => {
    console.log(info);
});

go mod init go-tonproject

go get github.com/xssnick/tonutils-go@latest

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/xssnick/tonutils-go/address"
	"github.com/xssnick/tonutils-go/liteclient"
	"github.com/xssnick/tonutils-go/ton"
)

func main() {
	client := liteclient.NewConnectionPool()

	// Add a connection to a custom Lite Server using the global config URL
	err := client.AddConnectionsFromConfigUrl(context.Background(), "https://ton.org/global.config.json")
	if err != nil {
		log.Fatalf("Connection error: %v", err)
	}

	// Initialize the API client with proof check policy
	api := ton.NewAPIClient(client, ton.ProofCheckPolicyFast).WithRetry()

	// Create a context bound to a single TON node
	ctx := client.StickyContext(context.Background())

	// Get the current masterchain block info
	block, err := api.CurrentMasterchainInfo(ctx)
	if err != nil {
		log.Fatalf("Error getting block info: %v", err)
	}

	// Specify the wallet address to check the balance
	walletAddr := address.MustParseAddr("EQ...")

	// Use WaitForBlock to ensure the block is ready
	account, err := api.WaitForBlock(block.SeqNo).GetAccount(ctx, block, walletAddr)
	if err != nil {
		log.Fatalf("Error getting account: %v", err)
	}

	// Display account information
	fmt.Printf("Is active: %v\n", account.IsActive)
	if account.IsActive {
		fmt.Printf("Status: %s\n", account.State.Status)
		fmt.Printf("Balance: %s TON\n", account.State.Balance.String())
	}
}

go mod init go-tonproject

go get github.com/tonkeeper/tongo@latest

package main

import (
	"context"
	"fmt"

	"github.com/tonkeeper/tongo"
	"github.com/tonkeeper/tongo/liteapi"
)

func main() {
	// options, err := config.ParseConfigFile("path/to/config.json")
	tongoClient, err := liteapi.NewClientWithDefaultMainnet()
	if err != nil {
		fmt.Printf("Unable to create tongo client: %v", err)
	}
	tonAddress := tongo.MustParseAddress("EQ...")
	state, err := tongoClient.GetAccountState(context.Background(), tonAddress.ID)
	if err != nil {
		fmt.Printf("Get account state error: %v", err)
	}

	fmt.Printf("Account status: %v\nBalance: %v\n", state.Account.Status(), state.Account.Account.Storage.Balance.Grams)
}

sudo apt install build-essential cmake libsodium-dev libsecp256k1-dev lz4 liblz4-dev

brew install readline secp256k1 ccache pkgconfig cmake libsodium

cargo new tonlib-rs-project
cd tonlib-rs-project

[dependencies]
tokio = { version = "1", features = ["full"] }
tonlib = "0.15"
anyhow = "1.0"

use tonlib::address::TonAddress;
use tonlib::client::TonClient;
use tonlib::client::TonClientInterface;
use anyhow::Result;

async fn get_state() -> Result<()> {  
    let client = TonClient::builder().build().await?;
    
    let address = TonAddress::from_base64_url(
        "EQ...",
    )?;
    
    let r = client.get_account_state(&address).await?;
    println!("Account balance: {:?}", r.balance);

    Ok(())
}

#[tokio::main]
async fn main() {
    if let Err(e) = get_state().await {
        eprintln!("Error: {:?}", e);
    }
}

mkdir tonsdk-project
cd tonsdk-project
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install tonsdk tvm_valuetypes aiohttp

import asyncio
import aiohttp
from tonsdk.provider import ToncenterClient, prepare_address, address_state
from tonsdk.utils import TonCurrencyEnum, from_nano

async def get_wallet_balance(address: str):
    client = ToncenterClient(base_url="YOUR_CHAINSTACK_RPC_ENDPOINT", api_key="")
    address = prepare_address(address)
    
    async with aiohttp.ClientSession() as session:
        # Get the account state function and its arguments
        account_state_func = client.raw_get_account_state(address)
        
        # Invoke the function with the session
        account_state = await account_state_func['func'](session, *account_state_func['args'], **account_state_func['kwargs'])
        
        # Process the account state to get the balance
        account_state["state"] = address_state(account_state)
        if "balance" in account_state:
            if int(account_state["balance"]) < 0:
                account_state["balance"] = 0
            else:
                account_state["balance"] = from_nano(int(account_state["balance"]), TonCurrencyEnum.ton)
        
        return account_state["balance"]

address = "EQ..."
balance = asyncio.run(get_wallet_balance(address))
print(f"Balance: {balance} TON")

mkdir new-project
cd new-project
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install pytonlib

import requests
import asyncio
from pathlib import Path
from pytonlib import TonlibClient

async def get_address_balance(address):
    ton_config = requests.get('https://ton.org/testnet-global.config.json').json()
    keystore_dir = '/tmp/ton_keystore'
    Path(keystore_dir).mkdir(parents=True, exist_ok=True)

    client = TonlibClient(ls_index=4,
                        config=ton_config,
                        keystore=keystore_dir)

    await client.init()

    account_state = await client.raw_get_account_state(address)

    balance = int(account_state['balance']) / 1e9
    print(f"Balance: {balance} TON")

    await client.close()

if __name__ == "__main__":
    asyncio.run(get_address_balance("EQ..."))

mkdir new-project
cd new-project
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install pytoniq

import asyncio
from pytoniq import LiteClient

async def main():
    client = LiteClient.from_mainnet_config()
    await client.connect()

    account_state = await client.get_account_state("EQ...")
    print(f"Balance: {account_state.balance}")

if __name__ == "__main__":
    asyncio.run(main())

dotnet new console -n TonSdkNetProject
cd TonSdkNetProject

dotnet add package TonSdk.Client --version 0.3.10

using TonSdk.Client;
using TonSdk.Core;

class Program
{
    static async Task Main(string[] args)
    {
        var clientParams = new HttpParameters() { Endpoint = "YOUR_CHAINSTACK_ENDPOINT", ApiKey = "" };
        var client = new TonClient(TonClientType.HTTP_TONCENTERAPIV2, clientParams);

        var address = new Address("EQ...");
        var accBalance = await client.GetBalance(address);

        var balance = accBalance.ToDecimal() / 1_000_000_000;
        Console.WriteLine($"Balance: {balance} TON");

        client.Dispose();
    }
}

npm create ton@latest

import { Config } from '@ton/blueprint';

export const config: Config = {
    network: {
        endpoint: 'YOUR_CHAINSTACK_ENDPOINT',
        type: 'testnet',
        version: 'v2',
        key: 'YOUR_API_KEY',
    },
};

npx blueprint build

npx blueprint run