BusinessPersonal
Documentation

GET Retrieve a Transaction

GET /refund/v2/transactions/{transactionId}
GET /refund/v2/transactions/?referenceNumber={referenceNumber}

Suggest Edits

Development Guide

The 'Retrieve a Transaction' endpoints look-up and return a transaction by referenceNumber or transactionId for the purpose of a refunding a transaction.



1. Prepare headers, authentication & parameters:

The application must call the 'Retrieve a Transaction' endpoint with a GET HTTP method, providing the OAuth access_token, required header values and parameters.


There are two endpoints that can be used to lookup and retrieve a transaction for a refund:

  • Retrieve a transaction by transactionId | GET /refund/v2/transactions/{transactionId}

    OR

  • Retrieve a transaction by referenceNumber | GET /refund/v2/transactions/?referenceNumber={referenceNumber}


Note: MoneyGram uses the OAuth 2.0 framework. The application must use their OAuth client credentials to generate an access_token by calling the Get Access Token endpoint. The token is valid for 1 hour and must be passed as a header value in all subsequent API HTTP calls. Learn More


🚀

Launch Code Example:

👉
Refund - Retrieve by Reference Number - Headers
Open Recipe

.

👉
Refund - Retrieve by transactionId - Headers
Open Recipe



2. Provide the refundReasonCode as a query parameter:

The application must also provide the refundReasonCode in the request. This is an enumerated list, for a full list of accepted values see the enumerations API and optionally pass the refundfee as a query parameter to enable the fee to be refunded back to the customer. Learn More


🚀

Launch Code Example:

👉
Refund Retreive Transaction - Refund Reason Code
Open Recipe



3. Provide the refundFee as a query parameter (optional):

MoneyGram's policy is to always refund the fee to the consumer Learn More. There may be use cases where the application chooses to keep or refund the fee back to the consumer. The application can do this under the following conditions:


  • If the "refundFee": null or not provided, the fee will always be refunded in the response.

  • If the "refundFee": true the fee will be refunded in the response.

  • If the "refundFee": false the fee will not be refunded in the response.

Note: The application can submit a refund within 90 days of the transaction's send date Learn More


🚀

Launch Code Example:

👉
Refund Retreive Transaction - Refund Fee
Open Recipe



4. Make a request and handle the response:

The application must call the 'Retrieve a transaction' endpoint with a GET HTTP method. The application must build to handle the following response scenarios:


  • Success | Parse the Response | 200 OK HTTP Status
    When the 'Retrieve a transaction' by transactionId or referenceNumber endpoint responds with a 200 HTTP Status the response will typically return transactionStatus, transactionSubStatus , sender, receiver information.

  • Failed | Handle the Error | 400 Bad Request HTTP Status
    When the 'Retrieve a transaction' endpoint responds with 400 HTTP Status, specific error code/s will be returned with an array of offending fields. The application will need to resolve these errors and resubmit the request.

Note:

  • The refundId returned in the response is required by the 'Commit a Transaction' endpoint and must be stored and passed to it.
  • A refund can only be issued by the agentPartnerId that initiated the transaction.

🚀

Launch Code Example:

👉
Refund Retreive Transaction - 200 OK
Open Recipe

.

👉
Refund Retreive Transaction by Reference Number - 400 Bad Reqeust
Open Recipe



5. Communicate the transaction status to the customer:

The information returned can be used in a transaction summary feature and displayed on the application's UI.




6. You're Done! Proceed to Commit a Transaction API:

The application can next execute the refund by using the 'Commit a Transaction' endpoint. The application can only proceed to execute the refund if the 'Retrieve a transaction API' response provides a 200 OK HTTP state and the "availableForRefund": true is returned in the response payload.


Note:

  • To execute the refund, the transactionId returned in the payload must be persisted and used as a path parameter on subsequent 'Commit a Transaction' API.
  • To execute the refund, the refundId returned in the payload must be persisted and used as in the request body of the subsequent 'Commit a Transaction' API.


Business rules to code

🔎

Conditions to allow a refund: The transaction must be in the "AVAILABLE" status to issue a refund.



Video Tutorial


Code Examples download linkDownload code examples


Code Examples


Retrieve by transactionId

const axios = require('axios');
const { v4: uuidv4 } = require('uuid');

const retrieve = async () => {

    // Step 1: Read configuration values with upmost security
    const token = "your_access_token_from_oauth_response"
    // For production - api.moneygram.com & For test - sandboxapi.moneygram.com
    const host = "sandboxapi.moneygram.com";
    const url = 'https://' + host + '/refund/v2/transactions';

    // Step 2: Create the GET request headers & params
    const headers = {
        'Content-Type': 'application/json',
        'X-MG-ClientRequestId': uuidv4(), // New UUID for each request tracing
        'Authorization': 'Bearer ' + token,
    };
    
    const transactionId = "current_transaction_id";
    const params = {
        agentPartnerId: "your_partner_id",        
        refundReasonCode: "WRONG_SERVICE",
        userLanguage: "en-US",
        targetAudience: "AGENT_FACING",
        refundFee: false
    }

    try {
        // Step 3: Send the request and obtain the response
        axios.get(url + '/' + transactionId, { params, headers })
            .then(function (response) {
                // Step 4: Parse the success response and process further
                console.log(JSON.stringify(response.data, null, 2))
            })
            .catch(function (error) {
                // Step 5: Parse the error response and handle the errors
                if (error.response) {
                    console.log('Response status:', error.response.status);
                    console.log('Response body:', error.response.data);
                } else {
                    // TODO: handle generic errors
                    console.error('Error:', error.message);
                }
            });
    } catch (error) {
        // TODO: handle exception
        console.error('Error:', error.message);
    }
};

retrieve();

import requests
import uuid
import json

def retrieve():

    # Step 1: Read configuration values with upmost security
    token = "your_access_token_from_oauth_response"
    # For production - api.moneygram.com & For test - sandboxapi.moneygram.com
    host = "sandboxapi.moneygram.com";
    url = 'https://' + host + '/refund/v2/transactions';

    # Step 2: Create the GET request headers & params
    headers = {
        'Content-Type': 'application/json',
        'X-MG-ClientRequestId': str(uuid.uuid4()), # New UUID for each request tracing
        'Authorization': 'Bearer ' + token,
    }

    transactionId = "current_transaction_id";
    params = {
        'agentPartnerId': 'your_partner_id',        
        'refundReasonCode': 'WRONG_SERVICE',
        'userLanguage': 'en-US',
        'targetAudience': 'AGENT_FACING',
        'refundFee': 'false'
    }

    try:
        # Step 3: Send the request and obtain the response
        response = requests.get(url + '/' + transactionId, params=params, headers=headers)

        # Step 4: Parse the success response and process further
        if response.status_code == 200:
            parsed_response = json.dumps(json.loads(response.text), indent=2)
            print(parsed_response)
        else:
            # Print the error message if request fails
            # TODO: handle exception
            print("Request failed with status code:", response.status_code)
            print(json.loads(json.dumps(response.text, indent=4)))

    except requests.exceptions.RequestException as e:
        # Print any error that occurred during the request
        # TODO: handle exception
        print("An error occurred:", e)

retrieve()

package refund;

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 RetrieveByTransactionID {

    public static void main(String[] args) {
        // Step 1: Read configuration values with upmost security
        String token = "your_access_token_from_oauth_response";

        // For production - api.moneygram.com & For test - sandboxapi.moneygram.com
        String host = "sandboxapi.moneygram.com";

        // Step 2: Create the GET request headers & params
        // Mandatory Query params
        String agentPartnerId = "your_partner_id";
        String refundReasonCode = "WRONG_SERVICE";
        String userLanguage = "en-US";

        // Optional Query params
        String targetAudience = "AGENT_FACING";
        Boolean refundFee = false;

        // Mandatory Path params
        String transactionId = "current_transaction_id";

        String uri = "https://" + host + "/refund/v2/transactions/" + transactionId + "?"
                + "agentPartnerId=" + agentPartnerId
                + "&refundReasonCode=" + refundReasonCode
                + "&userLanguage=" + userLanguage
                + (targetAudience.isBlank() ? "" : "&targetAudience=" + targetAudience)
                + (refundFee == null ? "" : "&refundFee=" + refundFee);

        HttpClient httpClient = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(uri))
                .GET()
                .setHeader("Authorization", "Bearer " + token)
                .setHeader("X-MG-ClientRequestId", String.valueOf(UUID.randomUUID()))
                .build();

        try {
            // Step 3: Send the request and obtain the response
            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

            // Retrieve the status code and body from the response
            int statusCode = response.statusCode();

            // Step 4: Parse the success response and process further
            if (statusCode == 200) {
                String responseBody = response.body();
                System.out.println(responseBody);
            } else {
                // Step 5: Parse the error response and handle the errors
                String responseBody = response.body();
                System.out.println(responseBody);
            }
        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }

    }
}

Retrieve by referenceNumber

const axios = require('axios');
const { v4: uuidv4 } = require('uuid');

const retrieve = async () => {

    // Step 1: Read configuration values with upmost security
    const token = "your_access_token_from_oauth_response"
    // For production - api.moneygram.com & For test - sandboxapi.moneygram.com
    const host = "sandboxapi.moneygram.com";
    const url = 'https://' + host + '/refund/v2/transactions';

    // Step 2: Create the GET request headers & params
    const headers = {
        'Content-Type': 'application/json',
        'X-MG-ClientRequestId': uuidv4(), // New UUID for each request tracing
        'Authorization': 'Bearer ' + token,
    };
    
    const params = {
        agentPartnerId: "your_partner_id",
        referenceNumber: "your_reference_number",
        refundReasonCode: "WRONG_SERVICE",
        userLanguage: "en-US",
        targetAudience: "AGENT_FACING",
        refundFee: false
    }

    try {
        // Step 3: Send the request and obtain the response
        axios.get(url, { params, headers })
            .then(function (response) {
                // Step 4: Parse the success response and process further
                console.log(JSON.stringify(response.data, null, 2))
            })
            .catch(function (error) {
                // Step 5: Parse the error response and handle the errors
                if (error.response) {
                    console.log('Response status:', error.response.status);
                    console.log('Response body:', error.response.data);
                } else {
                    // TODO: handle generic errors
                    console.error('Error:', error.message);
                }
            });
    } catch (error) {
        // TODO: handle exception
        console.error('Error:', error.message);
    }
};

retrieve();

import requests
import uuid
import json

def retrieve():

    # Step 1: Read configuration values with upmost security
    token = "your_access_token_from_oauth_response"
    # For production - api.moneygram.com & For test - sandboxapi.moneygram.com
    host = "sandboxapi.moneygram.com";
    url = 'https://' + host + '/refund/v2/transactions';

    # Step 2: Create the GET request headers & params
    headers = {
        'Content-Type': 'application/json',
        'X-MG-ClientRequestId': str(uuid.uuid4()), # New UUID for each request tracing
        'Authorization': 'Bearer ' + token,
    }

    params = {
        'agentPartnerId': 'your_partner_id',
        'referenceNumber': 'your_reference_number',
        'refundReasonCode': 'WRONG_SERVICE',
        'userLanguage': 'en-US',
        'targetAudience': 'AGENT_FACING',
        'refundFee': 'false'
    }

    try:
        # Step 3: Send the request and obtain the response
        response = requests.get(url, params=params, headers=headers)

        # Step 4: Parse the success response and process further
        if response.status_code == 200:
            parsed_response = json.dumps(json.loads(response.text), indent=2)
            print(parsed_response)
        else:
            # Print the error message if request fails
            # TODO: handle exception
            print("Request failed with status code:", response.status_code)
            print(json.loads(json.dumps(response.text, indent=4)))

    except requests.exceptions.RequestException as e:
        # Print any error that occurred during the request
        # TODO: handle exception
        print("An error occurred:", e)

retrieve()


package refund;

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 RetrieveByReferenceNumber {

    public static void main(String[] args) {
        // Step 1: Read configuration values with upmost security
        String token = "your_access_token_from_oauth_response";

        // For production - api.moneygram.com & For test - sandboxapi.moneygram.com
        String host = "sandboxapi.moneygram.com";

        // Step 2: Create the GET request headers & params
        // Mandatory Query params
        String agentPartnerId = "your_partner_id";
        String referenceNumber = "your_reference_number";
        String refundReasonCode = "WRONG_SERVICE";
        String userLanguage = "en-US";

        // Optional Query params
        String targetAudience = "AGENT_FACING";
        Boolean refundFee = false;

        String uri = "https://" + host + "/refund/v2/transactions?"
                + "agentPartnerId=" + agentPartnerId
                + "&referenceNumber=" + referenceNumber
                + "&refundReasonCode=" + refundReasonCode
                + "&userLanguage=" + userLanguage
                + (targetAudience.isBlank() ? "" : "&targetAudience=" + targetAudience)
                + (refundFee == null ? "" : "&refundFee=" + refundFee);

        HttpClient httpClient = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(uri))
                .GET()
                .setHeader("Authorization", "Bearer " + token)
                .setHeader("X-MG-ClientRequestId", String.valueOf(UUID.randomUUID()))
                .build();

        try {
            // Step 3: Send the request and obtain the response
            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

            // Retrieve the status code and body from the response
            int statusCode = response.statusCode();

            // Step 4: Parse the success response and process further
            if (statusCode == 200) {
                String responseBody = response.body();
                System.out.println(responseBody);
            } else {
                // Step 5: Parse the error response and handle the errors
                String responseBody = response.body();
                System.out.println(responseBody);
            }
        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }

    }
}


API Structure


Header Parameters

FieldQueryRequired
/Optional		Description
X-MG-ClientRequestIdStringOptionalClient Request ID that can be passed by the client application. Client request ID must be unique within a single session for unique requests. This attribute can be used for ensuring idempotent request processing for some APIs. MoneyGram recommends using a UUID for the value of this field.
X-MG-ConsumerIPAddressStringOptionalIP Address of the system initiating the session


Query Parameters

FieldTypeRequired
/Optional		Description
targetAudienceStringOptionalTailors MoneyGram’s error messages and field metadata to an in-store, digital or crypto customer. (Enumerated value)

NOTE: For a full list of accepted target audience values. See the TARGET_AUDIENCE enumeration from the Reference Data Enumerations endpoint
userLanguageString
Max length: 6		RequiredLanguage used by the user/operator
agentPartnerIdString
Max length: 8		RequiredUnique agent or partner identifier
payoutIdStringOptionalPoint of sale identifier of the client performing the API Call
operatorIdStringOptionalOperator name or ID of the user performing the transaction. Name or ID must be populated from the agent/partner system and cannot be edited by the user.
referenceNumberString
Max length: 8		RequiredMoneyGram's reference number for the transaction
NOTE: Used only when retrieving a transaction by referenceNumber
refundReasonCodeStringRequiredReason for the refund (Enumerated Values)

NOTE: For a list of accepted enumerated values for refund reason code see the Reference Data API Module - Enumerations endpoint - SEND_REVERSAL_RSNS
refundFeeBooleanOptionalFlag to indicate if the fee will be refund for the transaction


Path Parameters

FieldTypeRequired
/Optional		Description
transactionIdStringRequiredUnique id of the transaction resource

NOTE: Used only when retrieving a transaction by transactionId


Response Fields

FieldTypeRequired/
Optional		Description
transactionIdString
Max length: 36 		OptionalUnique identifier for the transaction resource
refundIdStringOptionalUnique identifier for the transaction session
transactionStatusStringOptionalMoneyGram's transaction status
transactionSubStatus.subStatusStringOptionalLatest sub-status of transaction
transactionSubStatus.messageStringOptionalMessage associated with the sub-status code.
transactionSubStatus.targetCustomerStringOptionalCustomer associated with sub-status code
transactionSubStatus.dataToCollect.codeStringOptionalUnique code to identify the data or document to collect
transactionSubStatus.dataToCollect.dataCollectionStringOptionalData or document needed to be collected from customer
availableForRefundBooleanOptionalFlag to indicate the transaction is available for refund
originatingCountryCodeString
Max Length: 3		OptionalTransaction country of Origin (ISO alpha-3 code)

NOTE: For a full list of accepted destinationCountryCode ISO codes see Reference Data API Module’ and the /countries/{iso3Code} endpoint
destinationCountryCodeString
Max Length: 3		OptionalTransaction Destination Country (ISO alpha-3 code)

NOTE: For a full list of accepted destinationCountryCode ISO codes see Reference Data API Module’ and the /countries/{iso3Code} endpoint
serviceOptionCodeString
Max length: 21		RequiredUnique category code to identify the transaction method

NOTE: For a full list of accepted serviceOptionCodes per destinationCountry see Reference Data API Module and the Service Options endpoint_
serviceOptionNameString
Max length: 50		OptionalUnique name to identify the transaction method

NOTE: For a full list of accepted serviceOptionName per destinationCountry see Reference Data API Module’ and the Service Options endpoint
serviceOptionRoutingCodeString
Max length: 21		OptionalUnique identifier of the individual banking, wallet, or card provider for the service option.

NOTE: For a full list of accepted serviceOptionCodes per destinationCountry see Reference Data API Module and the accountDeposit endpoint
serviceOptionRoutingNameString
Max length: 50		OptionalUnique name to identify the individual transaction method
sendAmount.amount.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredTransaction amount and currency excluding fees and exchange rate. Transaction Currency (ISO alpha-3 code)

NOTE: For Crypto partners this is the fiat currency for the BUY/Sell or Ramp-on/Ramp-off
sendAmount.amount.currencyCodeStringRequiredThe sendAmount.amount.value currency code (ISO alpha-3 code)
sendAmount.fees.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredFee Amount and Fee Currency applied to transaction (Fee Currency usesISO alpha-3 code)
sendAmount.fees.currencyCodeStringRequiredThe sendAmount.fees.value currency code (ISO alpha-3 code)
sendAmount.taxes.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		OptionalTax Amount and Tax Currency applied to the Transaction by the the origin country (Tax Currency uses ISO alpha-3 code)
sendAmount.taxes.currencyCodeStringOptionalThe sendAmount.taxes.value currency code (ISO alpha-3 code)
sendAmount.discountsApplied.totalDiscountString
Min length: 0
Max length: 14
Max Decimal Value: 3		OptionalTransaction discount amount applied and currency type excluding fees and exchange rate. Transaction Currency (ISO alpha-3 code)
sendAmount.discountsApplied.promotionDetailsStringOptionalAdditional Details about the applied promotion to the transaction
sendAmount.total.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredTransaction Total Amount and Transaction Total Currency including fees, taxes and discount. (Transaction Total Amount uses ISO alpha-3 code)
sendAmount.total.currencyCodeStringRequiredThe sendAmount.total.value currency code (ISO alpha-3 code)
refundAmount.amount.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredTransaction Refund Amount and Transaction Refund currency (Transaction Total Amount uses ISO alpha-3 code)
refundAmount.amount.currencyCodeStringRequiredThe refundAmount.amount.value currency code (ISO alpha-3 code)
refundAmount.fees.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredReceived Fee and Receive Currency applied to the transaction by the destination country (Transaction Total Amount uses ISO alpha-3 code)
refundAmount.fees.currencyCodeStringRequiredThe refundAmount.fees.value currency code (ISO alpha-3 code)
refundAmount.taxes.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		OptionalTax Amount and Tax Currency applied to the Transaction by the the origin country (Tax Currency uses ISO alpha-3 code)
refundAmount.taxes.currencyCodeStringOptionalThe refundAmount.taxes.value currency code (ISO alpha-3 code)
refundAmount.total.valueString
Min length: 0
Max length: 14
Max Decimal Value: 3		RequiredThe total refund amount (transaction send amount, & fees - if refundFee: "true") and currency type (Currency type uses ISO alpha-3 code)
refundAmount.total.currencyCodeStringRequiredThe refundAmount.total.value currency code (ISO alpha-3 code)
sender.name.firstNameString
Min length: 1
Max length: 20		RequiredFirst Name
sender.name.middleNameString
Min length: 1
Max length: 20		OptionalMiddle Name (if applicable)
sender.name.lastNameString
Min length: 1
Max length: 30		OptionalLast Name
sender.name.secondLastNameString
Min length: 1
Max length: 30		OptionalSecond Last Name (if applicable)
sender.profileIdStringOptionalUnique Identifier of the consumer.
sender.additionalDetailsDynamicOptionalDynamic field key/values
receiver.name.firstNameString
Min length: 1
Max length: 20		RequiredFirst Name
receiver.name.middleNameString
Min length: 1
Max length: 20		OptionalMiddle Name (if applicable)
receiver.name.lastNameString
Min length: 1
Max length: 30		OptionalLast Name
receiver.name.secondLastNameString
Min length: 1
Max length: 30		OptionalSecond last name (if applicable)
additionalDetailsDynamicOptionalDynamic field key/values

Updated 11 days ago

Moneygram Logo
Media Center Privacy Center Terms of Use Become an agent MoneyGram Money Transfer
LinkedIn Facebook Instagram Twitter Youtube

Authorized to do business in all 50 states, D.C. and all U.S. territories, NMLS #898432. Licensed as a Money Transmitter by the New York State Department of Financial Services. Massachusetts Check Seller License #CS0025, Foreign Transmittal License #FT89432. MoneyGram. MoneyGram Payment Systems, Inc. is registered as a Money Services Business under FinCEN, Registration #. 31000221116940. MoneyGram and the Globe are marks of MoneyGram. All other marks are the property of their respective owners. © 2023 MoneyGram