About Transactions

This guide describes general characteristics of transactions in the Galileo system. For an explanation of how card transactions work specifically, consult About Card Transactions.

In the Galileo system, “transaction” describes any movement of funds into or out of a customer account. Transaction types include payment-card transactions, direct deposits, ACH transfers, cash loads, ATM fees, and other types of money movement.

Transactions are central to any banking app. Your customers expect to use your product to create transactions and to see a history of their transactions. You can enable them to do both by using Galileo's API.

Creating transactions

Transactions are created in two primary ways:

  • Using the API — The transaction can be initiated by:
    • Your customers on your web site or mobile app, such as an ACH credit
    • You, according to your business logic, such as assessing a fee
  • Outside the API — The transaction can be initiated by:
    • A card reader at a point of sale or ATM, such as a card purchase at a merchant site. See About Card Transactions for more information.
    • An external depositing entity, such as an employer making a direct deposit. See About ACH for more information.
    • An external debiting entity, such as a utility automatically withdrawing a billing amount

For the transactions that are created outside of your programmatic control, you can be notified of them by consuming the Auth API webhook or the Events API webhook, obtaining Transaction History via API, or consuming the daily RDFs.

See About the Events API and About the Raw Data Files (RDFs) for more information.

📘

Note

Galileo recommends that you keep a record of all transactions in your own system by consuming the Events API and reconciling it against the daily RDFs, as explained in the Transaction History guide. You should also create an identifier in your system for each transaction that is unique across all transactions. See the Mapping Transactions Within Your System guide for more information.

Classifying transactions

Each transaction is classified by its activity category and transaction type.

Activity category

All transactions belongs to one of four activity categories:

  • Authorization/Settlement — A transaction that occurs over a card network's rails (system), such as when a cardholder initiates a purchase at a store.
  • Payment — A transaction by which funds are moved into a customer account, originating with the Program API or with an external source such as a paycheck deposit.
  • Adjustment — A transaction used to modify the customer's balance for various operational purposes, either a credit or debit, originating with the Program API or a direct debit from outside the API, such as an ACH transaction.
  • Fee — A transaction that charges a cardholder for a particular service, which may originate with the Program API or by an automated process.

The authorization/settlement category is broken down into multiple activity types, whereas payments, adjustments, and fees have only one activity type each. The activity types in the authorization/settlement category differentiate among card networks such as Mastercard and Visa and types of transactions such as authorizations, expired authorizations, backouts and settlements.

Galileo uses two capital letters to represent activity types. Some common authorization/settlement activity types are:

CodeActivity type
AUMastercard Banknet authorization
SEMastercard Banknet settlement
DBMastercard debit authorization
SDMastercard debit settlement
VIVisa authorization
VSVisa settlement
ISVisa Interlink settlement
PLVisa Plus settlement
EXExpired authorization

Non-network activity types are represented as follows:

CodeActivity type
PMPayment
ADAdjustment
FEFee

📘

Note

For a list of all activity types consult the Activity Type enumeration.

Transaction type

Each of the activity type categories is divided into more specific transaction types, often called otypes. For example, a payment could be a direct deposit, a cashier's check, or a cash load, among others.

A transaction type consists of one to four characters and may contain letters or numbers. Transaction types are case sensitive, so in the payment activity category, DC is a Discover chargeback whereas dc is a direct-load reversal.

A transaction type is unique only within the activity category. For example, Z is a bill-payment check in the adjustment activity category and a refund in the authorization/settlement activity category.

This table contains some authorization/settlement transaction types that are common to all networks:

CodeTransaction type
5Mastercard Banknet settlement
8Mastercard Banknet settlement for mobile wallet or peer-to-peer cash transfer
ARetail sale
BBalance inquiry
CPreauthorization completion
LPreauthorization
RReversal
WATM withdrawal
ZRefund

See the Transaction Types enumeration for a list of authorization/settlement transaction types. For payments, adjustments, and fees, the list of supported transaction types is specific to your use case and bank requirements. Galileo will provide you with a curated list of transaction types that you will be using.

Transaction codes

A transaction code (often designated trans_code) is a combination of an activity type (the first two characters) and a transaction type (the remaining characters). This table shows some common transaction types.

CodeActivity typeTransaction type
AUAAU — Mastercard Banknet authorizationA — Retail sale
SE5SE — Mastercard Banknet settlement5 — Settlement
DBADB — Mastercard debit authorizationA — Retail sale
SDASD — Mastercard debit settlementA — Retail sale
VILVI — Visa authorizationL — Preauthorization
ISCIS — Visa Interlink settlementC — Completion
PMVTPM — PaymentVT — Visa Money Transfer
ADHAD — AdjustmentH — Chargeback
FE0013FE — Fee0013 — Domestic ATM withdrawal fee

Because of this structure, a transaction code can be easily deconstructed to obtain the activity type and transaction type.

Activity type and transaction type in the Galileo system

The transaction code and its component parts are represented differently by different aspects of the Galileo system.

Program API

The program APIs return the transaction code, activity type and transaction type in these fields:

Endpointtrans_codeact_typetype
Get Account OverviewXX
Get Authorization HistoryX
Get Transaction HistoryXX
Get All Transaction HistoryXXX

Use the trans_code for reconciliation with the Posted Transactions RDF.

Events API

Authorization, Settlement, and Transaction Events messages break out the transaction code into two fields: activity type (act_type) and transaction type (otype).

Auth API

The activity type must be derived from the auth_type and subnetwork parameters. For example, if auth_type: Auth and subnetwork: Mastercard Debit Switch, then the activity type is DB (Mastercard Debit Authorization).

The transaction type is in the transaction_type parameter. However, the value will be a transaction-type description rather than the code. For example, you would see transaction_type: Balance Inquiry instead of B.

RDFs

The Posted Transactions RDFs includes the transaction code as TRANSACTION CODE/TYPE. The transaction code may be deconstructed to obtain the activity type and transaction type. Use the lookup file included with the RDFs to obtain the transaction code description.

📘

Note

The TRANSACTION CODE field in the Authorized Transactions RDF does not contain the trans_code. It contains a numeral that specifies the type of authorization that was requested. See the Authorization types list in the Transaction Types enumeration.

CST

On the All Transactions screen in the CST, the Type column contains the activity type description, and the Type field in the Details column contains the transaction type code.

This table summarizes the way transaction codes are represented in the Galileo system.

Galileo systemActivity type / transaction type
Get Account Overview
Get Transaction History
Get All Transaction History
trans_code
Events APIact_type / otype
Auth APIsubnetwork+ transaction_type
Posted Transactions RDFTRANSACTION CODE/TYPE
CSTType column / Type field in the Details column

Transaction properties

Among a transaction’s properties, the most important are amount, timestamp, and the category-specific properties.

Amount

The amount or amt field indicates how much money is involved in the transaction and specifies which direction the funds are moving: a positive amount means that money is entering the customer account (credit) and a negative amount means that money is leaving the account (debit).

The sign for the amount is represented differently in different Galileo systems.

RDFs

In the RDFs the TRANSACTION AMOUNT field is followed by the single-character TRANSACTION AMOUNT SIGN field, which contains either - (debit) or + (credit).

Auth API

In the Auth API the amount does not have a plus or minus sign. You must determine whether it is positive or negative by the transaction type. First, multiply the amount by –1, then multiply again by –1 for each of these conditions:

  • auth_type: Reversal
  • transaction_type: Merchant Credit
  • transaction_type: Payment

Program API

Amounts that credit a cardholder account have no sign, and amounts that debit an account are are preceded by a hyphen: 35.41 and -254.78.

Events API

Most events have no sign in the amount field, so you must infer whether the amount is credited or debited by the event type. For example, a BAUT: auth event is a debit whereas AAPM: auth_payment is a credit. On the other hand, FREV: fee_reversal contains a negative number because it is reversing out a fee. These exceptions are noted in each Event description.

Timestamp

Depending on the data source and the activity category, there may be one or two timestamps. If there are two timestamps showing different times, the earlier timestamp shows the time the transaction was initiated and the later timestamp shows when it was posted. For authorization/settlements, the first timestamp is the authorization and the second the settlement. If the two timestamps show the same time it means the transaction was posted immediately.

📘

Note

All Galileo timestamps are in the America/Phoenix time zone (MST -07:00), a time zone that does not observe daylight saving

Category-specific properties

Other properties of the transaction may be important, depending on which activity category the transaction belongs to. For example, mcc (merchant category code) is pertinent to authorizations and settlements, and related_transaction is pertinent to pending fees.

Linking transactions

Some transactions pass through multiple phases before completion, such as most card transactions (authorization/settlement), whereas fees are often connected to transactions that may or may not have originated on the card networks. The fields in this table can help you link related transactions.

Transaction typeLinked toLinking field
AuthorizationAuthorizationoriginal_auth_id
prior_id
original_id
Reversal ID
Settlement or postingAuthorization or non-network transactionauth_id
source_id
FeeAny transactionrelated_transaction

The linking fields for authorizations have different names in different systems, but they all contain the same value:

The linking fields contain the auth_id of a previous authorization in these circumstances:

  • The merchant performs incremental authorizations for a single purchase. Each authorization has the auth_id of the previous authorization in the chain.
  • An authorization or preauthorization is reversed. The reversal has the auth_id of the transaction to reverse in the linking field.
  • A preauthorization is followed by a completion. The completion contains the auth_id of the original preauthorization.
  • You charge a fee for a card transaction, such as an ATM fee. The fee is broken out separately from the settlement in the Posted Transactions RDF, and the fee entry has the auth_id of the original authorization. (The original authorization has the fee included in the amount instead of broken out.)

For authorization/settlement transactions the auth_id and source_id contain the same value. However, the source_id for a transaction that does not originate on a card network may or may not have an auth_id, but when the auth_id is present, the source_id is often different, because it maps to the specific transaction type such as a payment ID or fee ID. For example, a Maestro load payment (trans_code: PMMX) can have an auth_id in the Authorized Transactions RDF that maps to the auth_id in the Posted Transactions RDF, but the source_id is different, because it maps back to the payment ID.

In the CST, the ID field always maps to the source_id.

📘

Note

Also see the Transaction sequence examples in the Transaction History guide.

Transaction history

See the Transaction History guide for the various methods to retrieve and maintain an account’s transaction history.


Did this page help you?