Skip to main content
POST
/
getfibalance
Get FI Balance
curl --request POST \
  --url https://api.example.com/getfibalance

Overview

The Get FI Balance API retrieves the current account balance for one or more financial accounts associated with a specific consent, without fetching the complete transaction history. This lightweight endpoint is specifically designed to support Personal Finance Management (PFM) features where displaying current balances across multiple accounts is a primary use case, and detailed transaction information is not immediately required.
This API returns only balance information along with basic account identifiers. If you need complete transaction history or detailed account information, use the Get FI Data or Get All FI Data endpoints instead. The balance returned represents the most recent data available from the Financial Information Provider.

Use Cases

This API is particularly useful for:
  • PFM dashboard displays: Personal Finance Management applications that show users a consolidated view of all their account balances across different banks and financial institutions in a single interface.
  • Account summary pages: Portfolio management and wealth tracking applications that display high-level net worth calculations based on current account balances.
  • Quick balance checks: Mobile applications and widgets that provide users with at-a-glance balance information without the overhead of downloading complete transaction histories.
  • Net worth tracking: Financial planning tools that monitor changes in total asset values over time by tracking balance snapshots at regular intervals.
  • Multi-account aggregation: Services that consolidate balances from savings accounts, current accounts, fixed deposits, and recurring deposits to give users a complete picture of their liquid assets.

Authentication

All requests to this endpoint must include the following authentication headers:
HeaderTypeRequiredDescription
client_idstringYesThe unique client identifier assigned to your organization during onboarding. This value is available in the FinPro admin portal.
client_secretstringYesThe confidential client secret key paired with your client_id. Store this securely and never expose it in client-side code.
organisationIdstringYesYour organization’s unique identifier in the FinPro system, used to scope all API requests to your tenant.
appIdentifierstringYesThe application identifier that distinguishes different applications within your organization, useful for multi-product setups.
Content-TypestringYesMust be set to application/json to indicate the request body format.

HTTP Request

POST {{Base_URL}}/getfibalance

Request Parameters

ParameterTypeRequiredValidationDescription
consentIDstringYesMust be a valid GUID (Globally Unique Identifier) provided by the Account Aggregator after consent approval.The unique identifier for the consent record. This consent must be in ACTIVE status to retrieve balance data.
linkReferenceNumberstringNo*Must be a valid UUID that was previously provided by the Account Aggregator corresponding to the specified consent ID.The unique identifier for a specific financial account linked to this consent. If omitted, the API returns balances for all accounts under the consent.
*The linkReferenceNumber parameter is technically optional. When not provided, the API returns balance information for all accounts linked to the specified consent, making it very efficient for retrieving balances across multiple accounts in a single API call.

Request Body Example

Single account balance request:
{
    "linkReferenceNumber": "e72534d6-0016-4f0e-9da5-3e05ad405394",
    "consentID": "3c92001e-57ea-4320-bbb8-66d524bfb435"
}
All accounts balance request:
{
    "consentID": "3c92001e-57ea-4320-bbb8-66d524bfb435"
}

Response Format

Success Response

A successful response returns a JSON object containing balance information for the requested account(s), along with basic identification details.

Response Parameters

ParameterTypeRequiredDescription
statusstringNoIndicates whether the request was processed successfully. Typically set to “success” for successful requests.
verstringNoThe version number of the API specification being used in this response, useful for tracking API version compatibility.
dataobject or arrayYesContains balance information for the requested account(s). When a single linkReferenceNumber is provided, this is an object. When no linkReferenceNumber is provided, this is an array of account balance objects.
data.fiTypestringYesCategorizes the type of financial information, indicating the nature of the account from which balance is retrieved.
data.fipIdstringYesThe unique identifier for the Financial Information Provider (FIP) in the Account Aggregator ecosystem, typically representing the bank or financial institution.
data.fipNamestringYesThe human-readable name of the Financial Information Provider, useful for display purposes in user interfaces.
data.balancestringYesThe current account balance represented as a string to preserve decimal precision and avoid floating-point rounding errors.
data.linkReferenceNumberstringYesThe unique identifier linking this specific account to the consent, essential for correlating balance data with specific accounts.
data.maskedAccountNumberstringYesThe account number with most digits masked for security and privacy purposes, typically displaying only the last 4 digits (e.g., “XXXXXXXX3900”).
timestampstringNoThe server timestamp when this response was generated, useful for tracking data freshness and caching strategies.

Supported FI Types

FI TypeDescription
DEPOSITSavings or Current account balances, representing readily accessible liquid funds in checking or savings accounts.
TERM_DEPOSITFixed Deposit account balances, showing time-bound deposits with locked-in interest rates until maturity.
RECURRING_DEPOSITRecurring Deposit account balances, displaying accumulated value from regular installment deposits.
MUTUAL_FUNDSMutual fund investment values, though less commonly supported by this balance-focused endpoint.

Response Examples

Single account response:
{
    "ver": "1.21.0",
    "status": "success",
    "data": {
        "fiType": "DEPOSIT",
        "fipId": "finsharebank",
        "fipName": "FinShareBankServer",
        "balance": "101666.33",
        "linkReferenceNumber": "e72534d6-0016-4f0e-9da5-3e05ad405394",
        "maskedAccountNumber": "XXXXXXXX3900"
    }
}
Multiple accounts response:
{
    "ver": "1.21.0",
    "status": "success",
    "data": [
        {
            "fiType": "DEPOSIT",
            "fipId": "finsharebank",
            "fipName": "FinShareBankServer",
            "balance": "101666.33",
            "linkReferenceNumber": "e72534d6-0016-4f0e-9da5-3e05ad405394",
            "maskedAccountNumber": "XXXXXXXX3900"
        },
        {
            "fiType": "TERM_DEPOSIT",
            "fipId": "finsharebank",
            "fipName": "FinShareBankServer",
            "balance": "500000.00",
            "linkReferenceNumber": "a45678b9-1234-4567-89ab-cdef12345678",
            "maskedAccountNumber": "XXXXXXXX4567"
        },
        {
            "fiType": "RECURRING_DEPOSIT",
            "fipId": "anotherbank",
            "fipName": "AnotherBankServer",
            "balance": "75000.50",
            "linkReferenceNumber": "b56789c0-2345-5678-90bc-def123456789",
            "maskedAccountNumber": "XXXXXXXX7890"
        }
    ]
}

Error Handling

Error Response Format

When an error occurs during request processing, the API returns a standardized error response containing diagnostic information to help identify and resolve the issue.
FieldTypeRequiredDescription
verstringOptionalThe API version number, included when the error occurs after version validation.
timestampstringOptionalThe exact time when the error was encountered, useful for log correlation and debugging across distributed systems.
errorCodestringOptionalA machine-readable error identifier that categorizes the type of failure, enabling programmatic error handling logic.
errorMsgstringOptionalA human-readable description of the error, providing context about what went wrong and potentially suggesting resolution steps.
statusstringOptionalSet to “failure” to indicate the request did not complete successfully, distinguishing error responses from successful ones.

Common Error Codes

Error CodeError MessagePayload ExampleDescriptionResolution
InvalidRequest”[linkReferenceNumber is required] [consentID is required]“{}Both mandatory fields are missing from the request body.Include at minimum the consentID parameter in the request body.
InvalidRequest”[consentID is required]“{"linkReferenceNumber": "7f8227f1-697f-40d3-a4af-0508f5d0a1dd"}The consentID parameter is missing, which is mandatory for all requests.Add the consentID parameter to your request body.
InvalidRequest”[linkReferenceNumber is required]“{"consentID": "abc123"}In some configurations, linkReferenceNumber may be required. This is typically not the case, but may occur in specific deployment scenarios.Add a valid linkReferenceNumber or verify your API configuration with FinPro support.
InvalidConsentId”Consent ID does not exist”N/AThe provided consent ID is not found in the system or belongs to a different organization.Verify the consent ID is correct, active, and belongs to your organization.
InvalidLinkReference”Link Reference Number does not exist” or “Link Reference Number not associated with this consent”N/AThe linkReferenceNumber is invalid or doesn’t belong to the specified consent.Check that the linkReferenceNumber was obtained from a webhook notification for this specific consent.
ConsentNotActive”Consent is not in active state”N/AThe consent has been paused, revoked, or expired, preventing balance data access.Check the consent status and obtain a new consent approval if needed.
DataNotAvailable”Balance data not available”N/AThe FIP has not yet provided balance information, or data fetch is still in progress.Wait for the DATA_READY webhook notification before attempting to retrieve balance data.
Unauthorized”Invalid credentials”N/AThe authentication headers are incorrect, missing, or the credentials have expired or been revoked.Verify your client_id, client_secret, organisationId, and appIdentifier are correct and active in the FinPro portal.
RateLimitExceeded”Too many requests”N/AThe API rate limit has been exceeded for your organization within the current time window.Implement exponential backoff, reduce request frequency, and check X-RateLimit-* response headers for guidance.

Error Response Example

{
    "ver": "1.21.0",
    "timestamp": "2025-11-14T11:51:28.773Z",
    "errorCode": "InvalidConsentId",
    "errorMsg": "Consent ID does not exist.",
    "status": "failure"
}

Supported Account Types

This API retrieves balance information for the following account types:
  • Current Account: Business or high-transaction-volume checking accounts, typically with no minimum balance requirements or transaction limits.
  • Savings Account: Personal deposit accounts that earn interest on the balance, often with some transaction limits and minimum balance requirements.
  • Fixed Deposit (Term Deposit): Time-bound deposits with fixed interest rates, where the balance represents the principal plus any accrued interest up to the query date.
  • Recurring Deposit: Regular installment-based savings schemes where the balance shows the cumulative value of all deposits made plus any accrued interest.
The specific account types available depend on the consent configuration, the capabilities of connected Financial Information Providers, and what accounts the user has chosen to link during the consent approval process.

Usage Notes and Best Practices

Retrieving Multiple Account Balances

  • The most efficient way to retrieve balances for all accounts under a consent is to omit the linkReferenceNumber parameter entirely, which returns balance data for all linked accounts in a single API call.
  • This bulk retrieval approach significantly reduces the number of API calls required for multi-account scenarios, improving application performance and reducing load on both client and server.
  • When processing multiple accounts, iterate through the returned array and handle each account’s balance data independently, accounting for different FIP providers and account types.

Data Freshness and Balance Accuracy

  • The balance returned represents the most recent data fetched from the Financial Information Provider, which may not be real-time depending on the FIP’s data provision schedule.
  • For PERIODIC consents, balance data is refreshed according to the fetch frequency configured in your consent template (e.g., daily at midnight, weekly on Sundays).
  • For ONETIME consents, the balance represents a snapshot at the time of initial data fetch and will not update automatically; users must initiate a new consent for updated information.
  • Different banks and financial institutions have varying data update cycles; some provide near-real-time balance updates while others may have delays of several hours or update only once daily.

Balance Display and Formatting

  • Balance values are returned as strings to preserve decimal precision; convert to numeric types carefully, using decimal or big number libraries to avoid floating-point precision errors.
  • Always display currency symbols and formatting according to user locale preferences or the currency field if provided (typically INR for Indian accounts).
  • Consider the account’s currency denomination when displaying balances, especially for forex accounts or international banking integrations.
  • The masked account number provides just enough information for users to identify accounts while maintaining security; display this prominently alongside balance information.
  • Always verify that a consent is in ACTIVE status before attempting to retrieve balance data, as paused, revoked, or expired consents will return errors.
  • Monitor webhook notifications for consent lifecycle events (PAUSE, REVOKE, EXPIRE) and update your local consent status to prevent unnecessary API calls to inactive consents.
  • Implement cache invalidation logic that clears cached balance data when consent status changes to inactive, preventing display of stale information.

Caching Strategy for Balance Data

  • Balance information changes relatively infrequently compared to the rate at which users might query it, making caching an effective optimization strategy.
  • Implement time-based cache expiration aligned with your consent’s fetch frequency (e.g., if data refreshes daily, cache balances for 23 hours).
  • Consider implementing a “refresh” mechanism that allows users to explicitly trigger a new balance fetch when they need the latest information.
  • Store the timestamp of the last balance fetch in your cache metadata to display data age to users, maintaining transparency about data freshness.

Rate Limiting and Performance Optimization

  • This lightweight endpoint has lower computational overhead than transaction-fetching endpoints, but rate limits still apply to prevent abuse.
  • Batch balance retrieval by using the multi-account capability (omitting linkReferenceNumber) rather than making individual API calls for each account.
  • Implement client-side request throttling to spread API calls over time, especially during peak usage periods or when syncing data for many users simultaneously.
  • Monitor the X-RateLimit-* headers in API responses to track your current usage against limits and adjust request patterns proactively.

Error Handling and Graceful Degradation

  • When balance data is unavailable for any reason, consider displaying the last successfully retrieved balance with a clear indicator of staleness rather than showing no information.
  • Implement retry logic with exponential backoff for transient failures, but respect terminal error states (invalid consent, authorization failures) to avoid wasted API calls.
  • For multi-account balance requests, handle partial failures gracefully; if one account’s balance is unavailable, still display balances for accounts that succeeded.
  • Log all error responses with full context (consent ID, link references, timestamp) to facilitate troubleshooting and identify systematic issues.

Integration with Transaction Data

  • Use this endpoint for displaying quick balance summaries, then fetch detailed transaction history on-demand when users drill down into specific accounts.
  • Cross-reference balance values from this endpoint with calculated balances from transaction history to detect discrepancies that might indicate data quality issues or missing transactions.
  • Consider implementing a reconciliation process that compares the balance from this endpoint with the most recent transaction balance to validate data consistency.

Privacy and Security Considerations

  • Balance information is sensitive financial data; ensure all storage, transmission, and display of this data complies with relevant data protection regulations (GDPR, DPDPA, etc.).
  • Implement appropriate access controls to ensure users can only view balances for their own consents and accounts.
  • Log access to balance data for audit trails, but sanitize logs to prevent exposure of actual balance values in production logging systems.
  • When displaying balances in user interfaces, consider implementing additional authentication (biometric, PIN) for high-value account types.

Comparison with Other Data Endpoints

  • Get FI Balance vs Get FI Data: Use Get FI Balance when you only need current balance information without transaction details, significantly reducing response payload size and processing overhead.
  • Get FI Balance vs Get All FI Data: Get FI Balance is optimized for displaying balances across multiple accounts, while Get All FI Data provides comprehensive information including transactions, profiles, and summaries for in-depth analysis.
  • When to use Get FI Balance: Dashboard displays, quick balance checks, net worth calculations, account summary pages, or any scenario where transaction-level detail is not immediately needed.
  • When to use transaction endpoints: Spend analysis, transaction categorization, detailed account statements, reconciliation processes, or any feature requiring access to individual transaction records.
  • Get FI Data: Retrieves comprehensive transaction history and account details for a specific account, including all transactions within the consent period.
  • Get All FI Data: Fetches complete financial data including transactions, profiles, and summaries for all accounts linked to a consent.
  • Get All Latest Data: Retrieves only incremental updates for PERIODIC consents, optimized for regular synchronization without redundant data transfer.
  • Get FI Data XML: Provides account and transaction data in XML format for integrations requiring structured XML processing.