Getting Balances

# All balances
curl https://api.sandbox.movmint.io/client/balance \
  -H "Authorization: Bearer <access_token>" \
  -H "x-idempotency-key: $(uuidgen)"

# A single asset
curl "https://api.sandbox.movmint.io/client/balance?asset=USDC" \
  -H "Authorization: Bearer <access_token>" \
  -H "x-idempotency-key: $(uuidgen)"

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"

	"github.com/google/uuid"
)

const baseURL = "https://api.sandbox.movmint.io"

func main() {
	token := "<access_token>"

	req, _ := http.NewRequest(http.MethodGet, baseURL+"/client/balance?asset=USDC", nil)
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("x-idempotency-key", uuid.NewString())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != http.StatusOK {
		log.Fatalf("get balance failed (%d): %s", resp.StatusCode, body)
	}
	fmt.Println(string(body))
}

import { randomUUID } from "crypto";

const BASE_URL = "https://api.sandbox.movmint.io";

async function getBalances(token: string, asset?: string) {
  const url = new URL(`${BASE_URL}/client/balance`);
  if (asset) url.searchParams.set("asset", asset);

  const res = await fetch(url, {
    headers: {
      Authorization: `Bearer ${token}`,
      "x-idempotency-key": randomUUID(),
    },
  });

  if (!res.ok) {
    throw new Error(`Get balance failed (${res.status}): ${await res.text()}`);
  }
  return res.json();
}

console.log(await getBalances("<access_token>", "USDC"));

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.UUID;

public class GetBalance {

    private static final String BASE_URL = "https://api.sandbox.movmint.io";

    public static void main(String[] args) throws Exception {
        String token = "<access_token>";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/client/balance?asset=USDC"))
                .header("Authorization", "Bearer " + token)
                .header("x-idempotency-key", UUID.randomUUID().toString())
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() != 200) {
            throw new RuntimeException("Get balance failed (" + response.statusCode()
                    + "): " + response.body());
        }
        System.out.println(response.body());
    }
}

use uuid::Uuid;

const BASE_URL: &str = "https://api.sandbox.movmint.io";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let token = "<access_token>";

    let client = reqwest::Client::new();
    let resp = client
        .get(format!("{BASE_URL}/client/balance"))
        .query(&[("asset", "USDC")])
        .bearer_auth(token)
        .header("x-idempotency-key", Uuid::new_v4().to_string())
        .send()
        .await?;

    if !resp.status().is_success() {
        let status = resp.status();
        return Err(format!("get balance failed ({status}): {}", resp.text().await?).into());
    }

    let data: serde_json::Value = resp.json().await?;
    println!("{}", serde_json::to_string_pretty(&data)?);
    Ok(())
}

import uuid
import requests

BASE_URL = "https://api.sandbox.movmint.io"


def get_balances(token: str, asset: str | None = None) -> dict:
    params = {"asset": asset} if asset else {}
    resp = requests.get(
        f"{BASE_URL}/client/balance",
        headers={
            "Authorization": f"Bearer {token}",
            "x-idempotency-key": str(uuid.uuid4()),
        },
        params=params,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()


print(get_balances("<access_token>", "USDC"))

{
  "data": [
    {
      "client_account_id": "9f1c2d3e-4b5a-6789-abcd-ef0123456789",
      "organization_id": "1a2b3c4d-5e6f-7081-92a3-b4c5d6e7f809",
      "asset": "USDC",
      "ledger_account": "cl_acmecorp_funds_USDC",
      "available_balance": 10000.00,
      "pending_balance": 500.00,
      "total_balance": 10500.00,
      "created_at": "2026-06-01T09:00:00Z",
      "updated_at": "2026-06-24T12:04:55Z"
    }
  ]
}