Overview

Retrieves required fields and metadata for each account deposit service options for a destination country. The returned data indicates which bank, wallet, or card deposit fields to display in the UI, the values to collect from the customer, and the customer-facing labels to display for each account deposit service option.

Authentication & Authorization

MoneyGram uses the OAuth 2.0 framework. The application must use their OAuth client credentials to generate an accesstoken and pass it as a header value in subsequent HTTP calls.

Make a Request

The application must invoke the Retrieve Account Deposit Fields endpoint with an HTTP GET method. The application must provide the agentPartnerId, userLanguage anddestinationCountryCode as a query parameter to lookup and retrieve all serviceOptions and corresponding fields for the country. (i.e. Bank, Wallet and Card Deposit options).

Retrieve Account Deposit Fields by Destination Country | `GET: /reference-data/v1/account-deposit-fields\
NOTE: The API allows you to refine the lookup by adding a serviceOptionCode and serviceOptionRoutingCode parameters to the request.

Use the Retrieve Account Deposit Fields API to get the required targetAccount fields for service options listed below.
- CARD_DEPOSIT
- BANK_DEPOSIT
- DIRECT_TO_ACCT
- HOME_DELIVERY

The Retrieve Account Deposit Fields API will respond with an HTTP 200 OK status and an array of service options and fields for the given destination country.

👍
Good to know:
ISO Standards: The Account Deposit API uses ISO Standards for country values. MoneyGram provide other Reference Data APIs which can be queried to understand and list the supported values and associated metadata. Learn More
serviceOptions: MoneyGram provide other Reference Data APIs which can be queried to understand the supported service options per designation country. Learn More

Code Examples

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

const accountDepositFields = 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 + '/reference-data/v1/account-deposit-fields';

    // 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 = {
        targetAudience: "AGENT_FACING",
        agentPartnerId: "your_partner_id",
        userLanguage: "en-US",
        destinationCountryCode: "USA"
    }

    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);
    }
};

accountDepositFields();

import requests
import uuid
import json

def account_deposit_fields():

    # 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 + '/reference-data/v1/account-deposit-fields';

    # 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 = {
        'targetAudience': 'AGENT_FACING',
        'agentPartnerId': 'your_partner_id',
        'userLanguage': 'en-US',
        'destinationCountryCode': "USA",
    }

    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)

account_deposit_fields()

package status;

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

    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 userLanguage = "en-US";
        String destinationCountryCode = "USA";

        // Optional Query params
        String targetAudience = "AGENT_FACING";

        String uri = "https://" + host + "/reference-data/v1/account-deposit-fields?"
                + "agentPartnerId=" + agentPartnerId
                + "&userLanguage=" + userLanguage
                + "&destinationCountryCode=" + destinationCountryCode
                + (targetAudience.isBlank() ? "" : "&targetAudience=" + targetAudience);

        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 Request & Response Examples

curl --request GET \
     --url 'https://sandboxapi.moneygram.com/reference-data/v1/account-deposit-fields?targetAudience=AGENT_FACING&agentPartnerId=30150519&userLanguage=EN-US&destinationCountryCode=USA' \
     --header 'X-MG-ClientRequestId: 4c79b06f-a2af-4859-82c8-28cbb0bf361b' \
     --header 'accept: application/json' \
     --header 'authorization: Bearer ***************************'

[
  {
    "destinationCountryCode": "USA",
    "serviceOptions": [
      {
        "serviceOptionCode": "string",
        "serviceOptionName": "string",
        "serviceOptionRoutingCode": "12345678",
        "serviceOptionRoutingName": "string",
        "keyInfo": [
          {
            "key": "receiver.name.lastName",
            "dataType": "string",
            "fieldLabel": "Last Name",
            "required": true,
            "staticFieldOverRide": false,
            "fieldMin": "0",
            "fieldMax": "30",
            "regEx": null,
            "exampleText": "Use name on receiver bank statement to avoid error",
            "enumerationItem": null
          },
          {
            "key": "sender.mobilePhone.number",
            "dataType": "string",
            "fieldLabel": "Phone Number",
            "required": true,
            "staticFieldOverRide": false,
            "fieldMin": "6",
            "fieldMax": "14",
            "regEx": "[0-9]*",
            "exampleText": "1234567890",
            "enumerationItem": null
          },
          {
            "key": "targetAccount.accountNumberVerification",
            "dataType": null,
            "fieldLabel": "Re-enter Wallet Account Number",
            "required": true,
            "staticFieldOverRide": null,
            "fieldMin": "10",
            "fieldMax": "10",
            "regEx": "[0-9]*",
            "exampleText": "Your mobile phone number without country code",
            "enumerationItem": null
          },
          {
            "key": "sender.name.lastName",
            "dataType": "string",
            "fieldLabel": "Last Name",
            "required": true,
            "staticFieldOverRide": false,
            "fieldMin": "0",
            "fieldMax": "30",
            "regEx": null,
            "exampleText": null,
            "enumerationItem": null
          },
          {
            "key": "receiver.name.firstName",
            "dataType": "string",
            "fieldLabel": "First Name",
            "required": true,
            "staticFieldOverRide": false,
            "fieldMin": "0",
            "fieldMax": "20",
            "regEx": null,
            "exampleText": "Use name on receiver bank statement to avoid error",
            "enumerationItem": null
          },
          {
            "key": "sender.name.firstName",
            "dataType": "string",
            "fieldLabel": "First Name",
            "required": true,
            "staticFieldOverRide": false,
            "fieldMin": "0",
            "fieldMax": "20",
            "regEx": null,
            "exampleText": null,
            "enumerationItem": null
          },
          {
            "key": "targetAccount.accountNumber",
            "dataType": null,
            "fieldLabel": "Mobile Phone Number",
            "required": true,
            "staticFieldOverRide": null,
            "fieldMin": "10",
            "fieldMax": "10",
            "regEx": "[0-9]*",
            "exampleText": "Your mobile phone number without country code",
            "enumerationItem": null
          }
        ]
      }
    ]
  }
]

API Structure

Header Parameters

Field	Type	Required/ Optional	Description
`X-MG-ClientRequestId`	String	Required	Client 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 this field value.

Field

Type

Required/

Optional

Description

X-MG-ClientRequestId

String

Required

Client 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 this field value.

Query Parameters

Field	Type	Required/ Optional	Description
`targetAudience`	String	Optional	Tailors 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 theReference Data Enumerations endpoint
`agentPartnerId`	String	Required	Unique agent or partner identifier
`userLanguage`	String	Required	Language used by the user/operator
`destinationCountryCode`	String	Required	Transaction Destination Country (ISO alpha-3 code)
`serviceOptionCode`	String	Optional	Unique category code to identify the transaction method
`serviceOptionRoutingCode`	String	Optional	Unique code to identify the individual transaction method

Response Fields

Field	Type	Required/ Optional	Description
`destinationCountryCode`	String	Optional	Transaction Destination Country (ISO alpha-3 code)
`serviceOptions.serviceOptionCode`	String Max length: 21	Required	Unique category code to identify the transaction method NOTE: For a full list of accepted service option codes per destination country see theReference Data API Module: service-options endpoint
`serviceOptions.serviceOptionName`	String Max length: 40	Required	Consumer facing name to identify the transaction method NOTE: For a full list of accepted service option display names per destination country see theReference Data API Module: service-options endpoint
`serviceOptions.serviceOptionRoutingCode`	String	Optional	Unique code to identify the individual transaction method NOTE: For a full list of accepted service option routine codes per destination country see theReference Data API Module: service-options endpoint
`serviceOptions.serviceOptionRoutingName`	String Max length: 50	Optional	Unique name to identify the individual transaction method
`serviceOptions.keyInfo`	Array	Required	Array of account deposit field names and related field metadata

serviceOptions.KeyInfo Array Structure

FieldName/Metadata	Description	Example Value
`serviceOptions.keyInfo.Key`	Field name described in dot notation	`sender.name.firstName`
`serviceOptions.keyInfo.dataType`	Data type of the `key`	string, boolean, number
`serviceOptions.keyInfo.fieldLabel`	User facing label for the `key` for use on the UI. Can be overwritten if required.	First name
`serviceOptions.keyInfo.required`	Flag to Indicate if the `key` is required or optional	true
`serviceOptions.keyInfo.displayOrder`	UI display order for the `key`. NOTE: The`displayOrder` is only returned for a `Key` that begin with `targetAccount`.	"3" NOTE: The account-deposit-fields response may return one or more`targetAccount` fields for a service-option. The `displayOrder` will be listed in the recommended order they should be displayed on the UI.
`serviceOptions.keyInfo.fieldMin`	Min `Key` field length	"0"
`serviceOptions.keyInfo.fieldMax`	Max `Key` field length	"255"
`serviceOptions.keyInfo.regEx`	Regular expression for data validation of the `Key`.	"^(verview Retrieves req)*$"
`serviceOptions.keyInfo.exampleText`	Example field value	First name
`serviceOptions.keyInfo.enumerationItem`	An array of accepted values for the `key.`	Overview Retrieves required fields and metadata for each account deposit [service options](https://developer.moneygram.com