Retrieve company and card balance

GET/public/v1/core/cards/balance

Bearer token

Check how much is available on a specific card, and how much the company holds, in one call.

Returns the company's available balance together with the remaining balance of the cards you identify. Card balances account for pending authorisations, so this is the figure to check before triggering a top-up or approving a purchase: not the last statement closing balance.

You must identify the cards. Send nickname or last_four; this endpoint does not list every card in the company. status alone is not sufficient and returns 400.

Query parameters

nicknamestring

Exact card name. Required unless last_four is sent

Example testing

last_fourstring

Last four digits of the card. Required unless nickname is sent

statusstring

Optional. Narrow to one card status

Example active

balanceinteger

Example 3

Response

One object.

Field	Type	Description
`company_balance`	object	`{ amount, currency }` for the company funding account
`cards[]`	array	`{ card_id, nickname, last_four, status, balance, currency }` per matched card

Response schema from the OpenAPI document

Field	Type	Description
`status_code`	integer
`success`	boolean
`data`	object
`company_balance`	object
`amount`	number
`currency`	string
`cards`	object[]
`card_id`	string
`nickname`	string
`last_four`	string
`status`	string
`balance`	integer
`currency`	string
`meta`	object
`request_id`	string
`timestamp`	string

Errors

400 (neither nickname nor last_four supplied, or an invalid status), 401.

Cards (write)

401Unauthorized - missing or invalid Bearer token

Every error carries an errors[] array and a meta.request_id. See Errors for the full envelope.

GET/public/v1/core/cards/balance

curl -X GET 'https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer <access_token>'

const accessToken = process.env.QASHIO_ACCESS_TOKEN;

const response = await fetch('https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active', {
  method: 'GET',
  headers: {
    Accept: 'application/json',
    Authorization: `Bearer ${accessToken}`,
  },
});

if (!response.ok) {
  throw new Error(`Qashio API ${response.status}: ${await response.text()}`);
}

const { data, meta } = await response.json();
console.log(meta.request_id, data);

import https from 'node:https';

const url = new URL('https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active');

const payload = await new Promise((resolve, reject) => {
  const req = https.request(
    url,
    {
      method: 'GET',
      headers: {
      Accept: 'application/json',
      Authorization: `Bearer ${process.env.QASHIO_ACCESS_TOKEN}`,
      },
    },
    (res) => {
      let raw = '';
      res.on('data', (chunk) => (raw += chunk));
      res.on('end', () => resolve(JSON.parse(raw)));
    },
  );
  req.on('error', reject);
  req.end();
});

console.log(payload.data);

import os
import requests

url = "https://api.qashio.com/public/v1/core/cards/balance"
headers = {
    "Accept": "application/json",
    "Authorization": f"Bearer {os.environ['QASHIO_ACCESS_TOKEN']}",
}

params = {
    "nickname": "testing",
    "status": "active",
}

response = requests.get(url, headers=headers, params=params, timeout=30)
response.raise_for_status()

body = response.json()
print(body["meta"]["request_id"], body["data"])

<?php

$ch = curl_init('https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active');

curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST  => 'GET',
  CURLOPT_HTTPHEADER     => [
      'Accept: application/json',
      'Authorization: Bearer ' . getenv('QASHIO_ACCESS_TOKEN'),
  ],
]);

$response = curl_exec($ch);
curl_close($ch);

$body = json_decode($response, true);
print_r($body['data']);

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active", nil)
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+os.Getenv("QASHIO_ACCESS_TOKEN"))

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var out map[string]any
	json.NewDecoder(res.Body).Decode(&out)
	fmt.Println(out["data"])
}

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active')
request = Net::HTTP::Get.new(uri)
request['Accept'] = 'application/json'
request['Authorization'] = "Bearer #{ENV.fetch('QASHIO_ACCESS_TOKEN')}"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

body = JSON.parse(response.body)
puts body['data']

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

public class QashioExample {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active"))
        .header("Accept", "application/json")
        .header("Authorization", "Bearer " + System.getenv("QASHIO_ACCESS_TOKEN"))
        .method("GET", HttpRequest.BodyPublishers.noBody())
        .build();

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

    System.out.println(response.body());
  }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();

var request = new HttpRequestMessage(new HttpMethod("GET"), "https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", $"Bearer {Environment.GetEnvironmentVariable("QASHIO_ACCESS_TOKEN")}");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();

Console.WriteLine(await response.Content.ReadAsStringAsync());

import Foundation

var request = URLRequest(url: URL(string: "https://api.qashio.com/public/v1/core/cards/balance?nickname=testing&status=active")!)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "Accept")
let token = ProcessInfo.processInfo.environment["QASHIO_ACCESS_TOKEN"]!
request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")

let (data, _) = try await URLSession.shared.data(for: request)
print(String(data: data, encoding: .utf8)!)

Response

{
  "status_code": 200,
  "success": true,
  "data": {
    "company_balance": {
      "amount": 4891.5,
      "currency": "AED"
    },
    "cards": [
      {
        "card_id": "CAtygas4f8y2nsg9",
        "nickname": "Qashio Card - 1",
        "last_four": "4554",
        "status": "active",
        "balance": 0,
        "currency": "AED"
      }
    ]
  },
  "meta": {
    "request_id": "3adb2d16090c7b3bdbde3b326a814b30",
    "timestamp": "2026-09-09T10:07:52.143Z"
  }
}

{
  "status_code": 401,
  "success": false,
  "message": "Missing Bearer token",
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Missing Bearer token"
  },
  "errors": [
    {
      "code": "UNAUTHORIZED",
      "message": "Missing Bearer token",
      "field": "authorization"
    }
  ],
  "meta": {
    "request_id": "3adb2d16090c7b3bdbde3b326a814b30",
    "timestamp": "2026-09-09T10:07:52.143Z"
  }
}