General information

Flash Payments API is GraphQL-based, offering simple and developer-friendly querying experience. All data is exchanged in JSON format.

Flash Payments API playground is located here: https://api.uat.flash-payments.com.au/

Complete API docs

This documentation website does not have full list of API fields and methods. This is intentional. The full list of the API calls you can performs and the data fields you can send/receive is listed in the API Playground (click "DOCS" on the right hand side).

High level feature overview

You can search, visualise, or extract your data using our FlashConnect interface.

Instant local Australian deposit (aka pay-in)

Once registration is complete, a dedicated BSB and Virtual Account Number (VAN) for use within Australia will be assigned to you.

Any funds deposited to your VAN would increase your Flash Payments balance. We store and retain the reference attached to each deposit (e.g., an invoice number) to support your reconciliation or reporting needs.

By default, only you can deposit into your VAN. Third-party deposits are also supported, but this feature must be enabled separately

Deposits are typically processed in real time, but depending on the bank, there may be a delay of up to 24 hours.

You can configure webhook notifications to receive alerts for every deposit made to your VAN. Please visit FlashConnect to set up your deposit webhook.

You can manually reject unwanted deposits via the FlashConnect interface. The funds will be returned to the original sender bank account.

Local Australian withdrawal (aka pay-out)

The Flash Payments API enables you to withdraw funds from your Flash Payments balance. By default, only you are authorized to receive these withdrawals. Third-party withdrawals (also known as payouts) are available upon request and require separate activation.

If your payout involves a foreign exchange (FX) payment, it must be processed using the Australian Direct Entry system in accordance with legal requirements. Processing time may vary from immediate to a few hours. Other payouts are credited instantly.

If a payout fails, you will receive a webhook notification detailing the reason for the failure.

The payout remitter name is configurable. You can give us the remitter name as withdrawal.sender data property. This is especially useful for FX-linked payouts. If a Brazilian mama Katarina Oreiro sends money to her son in Australia, he will see his mom's name in the bank statement - "Payment from Katarina Oreiro".

Payouts can also be done via the FlashConnect interface.

Send or receive money internationally

You can send your Flash Payments balance internationally via our API and benefit from instant delivery to many countries with local instant payment systems (e.g. Philippines)

To initiate a payment, you must pre-create the sender and recipient via the API.

All entities in our database, including withdrawals, payments, senders, and recipients, can store your system’s unique identifier. Please refer to the externalId field in the API docs.

Payment delivery times depend on the recipient's country. While many are processed quickly, some may take additional time. You’ll be notified via webhook whenever the payment status changes.

You can send funds through an international payment to your Flash Payments account. A webhook notification will be triggered when we detect payments from other countries.

Security

The API token you generate expires in 4 hours. You can always use logout GraphQL mutation to expire it earlier.

You can't reset your own password until we verify your identity.

The FlashConnect interface supports Google and One-Time-Password logins.

Webhooks have cryptographic signatures.

IP address whitelisting feature is available from FlashConnect interface allowing login to our APIs from only preapproved addresses that you specify.

API rate limiting is in place to ensure stable performance of our service and prevent its potential abuse.

How to start

1. Contact with us via this page or by clicking the Intercom button on the bottom right of this page.

2. Explain what kind of services you are looking from Flash Payments.

3. We will examine your needs and explain how to get access to our UAT environment.

For more detailed instructions head to the Basics page.

Important notes

Breaking changes

While we will endeavour to not introduce any breaking changes they might still occur in the future. In that case we will communicate about the upcoming changes via your registered email.

GraphQL Playground

All the GraphQL queries can be sent via the GraphQL Playground or as a HTTP POST request to https://api.uat.flash-payments.com.au. Example:

echo '{
  "query":
    "{
       quote(input: {
         fromCurrency: AUD, toCurrency: USD, size: 9.9, currency: AUD
       })
       {
         bid ask symbol timestamp inverted
       }
     }"
}' | curl -X POST 'https://api.uat.flash-payments.com.au' \
-H 'authorization: Bearer YOUR_TOKEN' \
-H 'content-type: application/json' \
-d @-

All the responses are JSON and have at least one property data and optional property errors.

{
  "data": { ... },
  "errors": [ ... ]
}

Some of the GraphQL query parameters are required, others are optional. To understand if a variable/property is required you would need to check the API schema.

• Go to the GraphQL Playground and click the button "DOCS" on the right.

• Browse through queries, mutations, input and output types. Find a variable/property which have an exclamation mark at the end. E.g. fromCurrency: FromCurrency!.

• The exclamation mark denotes that the variable/property is mandatory.

Data cleansing is your responsibility

The user-agent HTTP header

It is a good idea to always send custom user-agent HTTP header value when doing requests to Flash Payments API. Here is why:

• In case of troubleshooting we will be able to trace and mitigate your support questions faster.

• You might be blocked by our automated firewall if your user agent is something generic like curl, Java-http-client, python-requests, Ruby, etc.

429 Too many requests

Our API have smart monitoring. It might temporary block your IP address if it thinks you are abusing the system. There are many various scenarios when you can be blocked, but we won't going to disclose them at any point of time due to security reasons.

For your initial tests, it may be easier and more practical to send data by embedding values directly into the GraphQL queries and mutations, as shown in the example below.

echo '{
  "query":
    "{
       quote(input: {
         fromCurrency: AUD, toCurrency: USD, size: 9.9, currency: AUD
       })
       {
         bid ask symbol timestamp inverted
       }
     }"
}' | curl -X POST 'https://api.uat.flash-payments.com.au' \
-H 'authorization: Bearer YOUR_TOKEN' \
-H 'content-type: application/json' \
-d @-

At the same time, to enable efficient and accurate handling of complex queries in code, we support sending GraphQL queries as JSON objects that consist of two properties: "query" and "variables". Here is how you can do it:

• Declare the $input variable in the QraphQL "query" string. The technology also requires you to declare the type of your input(s). See the QueryInput in the example below.

• Provide the "variables" object with the "input" property. The value of it must be a JSON object structured exactly as the QueryInput type.

echo '{
  "query":
    "query ($input: QuoteInput!) {
       quote(input: $input) { bid ask symbol timestamp inverted }
     }",
  "variables": { 
    "input": { "fromCurrency": "AUD", "toCurrency": "USD", "size": 9.9, "currency": "AUD" }
  }
}' | curl -X POST 'https://api.uat.flash-payments.com.au' \
-H 'authorization: Bearer YOUR_TOKEN' \
-H 'content-type: application/json' \
-d @-

Here is a screenshot of how a typical mutation looks like in the API Playground:

Same request as cURL:

echo '{
  "query":
    "mutation ($input: RecipientInput!) {
      createRecipient(input: $input) { code message recipient { id } }
    }",
  "variables": {
    "input": {
      "firstName": "Test",
      "lastName": "Lastest",
      "currency": "PHP",
      "accountIdType": "PH_CASH",
      "mobile": "+63 9121231234",
      "phCashoutNetwork": "MLHUILLIER",
      "address": {
        "building": "12th Floor Centerpoint Building",
        "street": "Julia Vargas Avenue corner Garnet Street",
        "suburb": "Pasig",
        "state": "manila",
        "country": "PH",
        "postcode": "1605"
      }
    }
  }
}' | curl 'https://api.uat.flash-payments.com.au' \
-H 'authorization: Bearer YOUR_TOKEN' \
-H 'content-type: application/json' \
-d @-

Most documentation examples utilise typical GraphQL input data for successfully executing queries.

It's strongly encouraged that you always submit complete and accurate data, as this reduces our compliance team's reviewing efforts and, as a result, speeds up transactions and provides a great experience for your customers.

At the same time, we recognise that gathering complete customer information can be technically challenging, particularly regarding country-specific address details or account information. As a result, our API documentation emphasises the required input fields based on the principle of minimal necessity.

Please pay attention to the exclamation mark ( ! ) next to the field type in the API schema specification from the "DOCS" section of our API Playground. Those are the required fields as it's demonstated on the screenshot below:

Please always verify that you have all required data to initiate a successful mutation or query.

If you use our multi-currency feature, you can exchange currency and convert funds between your master accounts in real-time.

Conversion fees are detailed in your contract and vary based on your use case and risk assessment.

The GraphQL schema defines statuses like this:

enum PaymentStatus {
  INITIALISING
  OPEN
  CLOSED
  FAILED
  CANCELLED
}

The status of a payment can be any of the following:

Payment Statuses:

• INITIALISING – a draft payment. It may or may not have all required information to be executed. Typically, this never happens through the API. Can be created via the Flash Payments app under certain circumstances.

• OPEN – The payment is in progress.

• CLOSED – The payment was successfully delivered.

• FAILED – An error occurred during processing.

• CANCELLED – The payment did not complete and was cancelled, usually by the Flash Payments operations team.

You can retrieve all or some of your withdrawals.

You can create withdrawals. By default you can withdraw only to your personal Virtual Account Number (VAN).

If you are a fully verified customer you can payout to any bank account number in Australia. You'd need to:

• have a recipient ID (see Recipients to query your address book); otherwise

• understand the supported delivery methods using the availableDeliveryMethods query and create a new recipient

Once you have the recipient ID, you can initiate a withdrawal.

You can retrieve all or some of your payments. If you are an organisation with multiple users then you have access to all their payments.

You can create payments. But before you need to:

• Have a recipient ID (see Recipients to query your address book); otherwise

• Understand the supported delivery methods using the availableDeliveryMethods query and create a new recipient

Once you have the recipient ID, you can initiate a withdrawal.

Upon detecting a deposit in a Flash Payments Virtual Account Number (VAN), we immediately record it as a deposit in our system.

The status of a successful deposit goes through the following lifecycle

INITIALISED->REVIEWING→CONFIRMED

If you choose to reject a deposit, its status goes through the following lifecycle instead:

INITIALISED->REVIEWING→CONFIRMED→REFUNDING→REFUNDED

If Flash Payments Compliance choose to reject a deposit, its status lifecycle goes through following stages:

INITIALISED→REVIEWING→REFUNDING→REFUNDED

Paste this query to the GraphQL Playground

The cleared is the Primary balance you see on the Flash Connect website.

The pending balance is typically not shown on the Flash Connect interface because it's rather short lived. If your Pending balance is not 0 then you can see it right next to the Primary balance.

If you omit the currencies input argument then the query would return all the currency balances you have. Contact us to enable more than just the default AUD currency.

Top up your UAT account balance

If you need to increase your UAT account balance please sign in to the Flash Connect website, open Deposits page, and click Send Test Deposit.

After fully registering with us, you get a BSB and a dedicated Virtual Account Number (VAN).

Every deposit to your VAN would increase your Flash Payments balance.

Every deposit can trigger a notification, keeping you informed in real time

The deposit data includes the payment reference (we call it externalReference in this API).

By default, only you are permitted to make deposits. However, we can enable third-party deposits for your account upon request. Once enabled, your account number functions as a local collection account, allowing others to deposit funds on your behalf.

We can also enable the feature. It allows you to programmatically create client accounts with dedicated BSB and account number for transactional purposes. You can give these bank account details to your clients to accept deposits. Once funds arrive, we will increase your account balance, and you will see a deposit with sub-client information linked to it.

To browse your deposits, you can use our interface.

The sub-client (aka merchant) feature allows you to create client accounts for deposit collection purposes. These virtual accounts can be issued to individuals, companies, or other organisations.

Each sub-client will receive a dedicated BSB and Vitrual Account Number (VAN) that you or your clients can use to accept and withdraw domestic AUD transfers within Australia.

The account name is your sub-client's name. For companies - it's their tradingAsName or legalName. For individuals - it's their fullName (firstName + middleName + lastName).

If your Flash account has a multi-currency feature enabled, each of your sub-clients will also have access to virtual accounts in the selected currencies for which you hold balances.

All sent to your sub-client Virtual Account Numbers (VANs) are booked on your (master-client's) corresponding account balances. Sub-clients can't have their own balances.

You can and on behalf of your sub-clients by providing the sub-client ID when you create withdrawals or payments. This sub-client record will then be used as the sender, linked to the transaction, and reported to the government.

Notifications via will provide important sub-client information as well.

The GraphQL schema defines statuses like this:

The status of a conversion can be any of the following:

• INITIALISED — A conversion record was created, but no further action has been taken. This status typically does not occur via the API.

• PENDING — The conversion is in progress. This is the usual status immediately after creation.

• CONVERTED — The conversion completed successfully. Your balances have been updated accordingly.

• FAILED — An error occurred during the conversion. This is usually a temporary state.

• CANCELLED — The conversion was not completed and has been cancelled. This action is typically performed by the Flash Payments operations team.

1. - query bank information to validate if we support your BSB, IBAN, BIC (aka Swift code).

2. depositDetails - query the accounts you can send deposits to in order to increase your Flash Payments balance.

3. - query countries/currency combinations we support and what the required bank account details are.

This query returns the same data as the Download CSV button on the Account Statement page of the Flash Connect.

The dates must be any ISO 8601 formatted dates.

const bodyJSON = {
  variables: {
    input: {
        fromDate: "2023-08-28T00:00:00+03:00",
    },
  },
  query: `
query ($input: StatementQueryInput!) {
  statement(input: $input) {
    succes code message fromDate toDate 
      rows {
        debit credit
    }
  }  
}`,
};

query($input: StatementQueryInput!) {
  statement(input: $input) {
    success
    code
    message
    fromDate
    toDate
    rows {
      debit
      credit
      # and many other fields
    }
  }
}

{
  "input": {
    "fromDate": "2023-08-28T00:00:00+03:00"
  }
}

{
  "data": {
    "statement": [
      {
        "success": true,
        "code": "GENERATED",
        "message": "Statement generated",
        "fromDate": "2023-08-27T21:00:00Z",
        "toDate": "2023-08-28T21:00:00Z",
        "rows": {
          [
            {
              "debit": 123.45,
              "credit": 0
            }
          ]
        }
      }
    ]
  }
}

The response dates are aways UTC. Timezones are always taken into account.

Refund deposit by ID

const bodyJSON = {
  variables: {
    id: "6053d4e0e3bc655e0598a742",
    input: {
      amount: 10,
      reason: "sent by mistake",
    },
  }, 
  query: `
mutation ($id: ID!, $input: RefundDepositInput!) {
  refundDeposit(id: $id, input: $input) {
    success code message
  }
}`,
};

mutation($id: ID!, $input: RefundDepositInput!) {
  refundDeposit(id: $id, input: $input) {
    success
    code
    message
  }
}

{ 
  "id": "6053d4e0e3bc655e0598a742",
  "input": { 
    "amount": 10, 
    "reason": "sent by mistake"
  }
}

{
  "data": {
    "refundDeposit": {
      "success": true,
      "code": "REFUND_SENT",
      "message": "Refund initiated successfully"
    }
  }
}

To convert between, say, AUD and EUR you should:

1. Request a tradeable quote with applicability: CONVERSION.

2. Retrieve the quote ID from the response.

3. Reference the quote ID when creating the conversion.

Get a tradable quote ID:

Convert funds:

1. You create a withdrawal. Your balance goes down by the withdrawal amount plus fee. INITIALISED

   1. We might internally review the transaction. INITIALISED-> REVIEWING

   2. If review goes well it will become pending. REVIEWING→ PENDING

   3. Otherwise it gets cancelled. REVIEWING→ CANCELLED

2. The transaction is sent to the recipient bank for processing. INITIALISED → PENDING

3. PENDING →

   • CONFIRMED - the recipient bank has the money now. Does not mean the beneficiary account number was credited though. Mostly FINAL status. Except when bank decides to return the funds, the withdrawal gets refunded (see step 4).

   • FAILED - NOT FINAL status. Depending on the processing error we have three scenarios now.

     • REFUNDED - see step 4 below.

     • CANCELLED - manual action. Your balance goes up by the amount, Flash Payments keeps the fee. FINAL status.

     • PENDING - rare case - retrying. Sometimes it might work. Go to item 3.

4. The recipient bank decided to return this transaction back to Flash Payments.CONFIRMED → FAILED → REFUNDED - usual way - automatic refunding. Your balance goes up by the withdrawal amount, Flash Payments keeps the fee. FINAL status.

Most common status transitions

Happy path

INITIALISED→REVIEWING→PENDING→CONFIRMED

Unhappy paths

Recipient bank accepts the payout but then returns it:

INITIALISED→PENDING→CONFIRMED→FAILED→REFUNDED

Recipient bank rejects the payout:

INITIALISED→PENDING→FAILED→REFUNDED

Flash Payments Compliance team rejects the payout:

INITIALISED→REVIEWING→CANCELLED

Testing/simulating unhappy paths

Typically, you want to adapt your system to handle the following common withdrawal scenarios:

1. Too long in the REVIEWING status

If your withdrawal is in this status this means that we are doing an internal review of it. It happens occasionally when you trigger our monitoring rules. Also, this means that we have sent your Compliance Team (or else) an email message requesting more information. You must respond. In other words, if there is a delay - it's on you. Because Flash Payments delivers all your transactions in real-time 24/7.

You can simulate the behaviour. Your externalReference must include this text: HALT_AML. For example: "testing HALT_AML attempt 2". The withdrawal will get stuck in REVIEWING forever.

2. Fails AML and gets cancelled

We checked the data you sent us for withdrawal. We didn't like it. So we cancel it immediately.

You can simulate the behaviour. Your externalReference must include this text: FAIL_AML. For example: "testing FAIL_AML attempt 4". The withdrawal will be cancelled next moment after you submit it.

3. Recipient bank rejects the money

A common scenario in the Australian domestic payment system involves a transaction that appears successful initially, but is later reversed by the recipient’s bank—sometimes days after processing. This can happen for various reasons, such as an invalid or closed account number, an account in the wrong currency, or other account-related issues.

You can simulate the behaviour. Your externalReference must include this text: FAIL_ACC. For example: "testing FAIL_ACC attempt 8". The withdrawal will be completed, and next moment failed and refunded.

Event notifications with webhooks

Flash Payments uses webhooks to notify your application when a transaction event happens in your account. This includes status update of your withdrawal, clearing of the incoming deposit, and more.

With webhooks, you can subscribe to the events of interest to trigger a subsequent action within your integration.

There are two steps to begin using webhooks. Building a custom endpoint on your server and registering it via the settings.

Building webhook endpoint

Each time a transaction event happens, we will send a HTTP POST request to your endpoint(s) that are subscribed to that event. The payload with event data is in the JSON format and can be used immediately. Every webhook endpoint must acknowledge the request, and as we strongly advise, verify the webhook signature.

Acknowledging request

To acknowledge the receipt of the event, your endpoint must return 2xx HTTP status code. All other response codes, including 3xx codes, indicate that you did not receive the event.

If we do not receive 200 HTTP status code, we will make up to 3 more request attempts. There is 6, 60 and 600 seconds delay between each delivery attempt respectively. If all request attempts fail, we mark webhook request as failed and will no longer try to deliver it.

Each webhook request has a flashfx-request-id header with a string that uniquely identifies a webhook event. For example, if there are multiple delivery attempts for the webhook event, each request will hold the same flashfx-request-id. This can be used to check if the webhook event was already processed by your application.

We advise that you acknowledge webhook request as early as possible.

Securing the request

To ensure that webhook was sent by Flash Payments and not a third party, we include the cryptographic signature in each request’s flashfx-signature header.

Before you can verify a signature, you need to retrieve your endpoint’s secret from webhook settings in the . Each registered endpoint has a unique secret that is used to sign a payload delivered to you on each event. Steps to verify signature:

1. Extract signature from the request header

2. Compute HMAC with SHA256 function. Use your endpoint secret as key and JSON payload string as a message.

3. Compare signature in the header to the computed signature.

Here is a Node.js pseudo code to generate and compare signatures

And verifying signature

Testing your endpoint

To make sure your webhook endpoint is setup correctly, you can make a test HTTP request from the webhook settings. Click the "Send Test” button. You should receive a dummy request, which will need to be acknowledged the same way as your real webhook requests.

Subscribing to the events

Webhook requests come with event data. You can see all available event types in the settings. To subscribe, select which events you would like to receive and specify your endpoint. Please note, your endpoint must adhere to the HTTPS protocol for security reasons.

When , or you can provide us a webhook (callback) URI - callbackUri. We will call it when a payment or withdrawal status changes.

We recommend API clients to generate and add ?signature=ASecretPerPaymentKey query to your callbackUri to make sure it's Flash Payments calling your webhook endpoint. For example:

To avoid storing the signatures in a database we recommend generating them on the fly using a strong hash function or any kind of cryptography.

Example

You would need to implement two functions.

1. Function to generate "signature".

2. Function to verify the "signature".

Generating signatures

Node.js pseudo code for creating transfers in Flash Payments API.

The code above creates a callbackUri and externalId variables. Use both of them when creating a transfer in Flash Payments API.

Verifying signatures

Node.js pseudo code of the webhook endpoint HTTP request handler.

Please verify that you have all the required data to initiate a successful payment transfer.

List all the available payment delivery methods

const bodyJSON = {
  variables: {
    input: {
    },
  }, 
  query: `
query ($input: AvailableDeliveryMethodsInput!) {
  availableDeliveryMethods(input: $input) {
    country currency method requiredFields
  }
}`,
};

query($input: AvailableDeliveryMethodsInput!) {
  availableDeliveryMethods(input: $input) {
    country
    currency
    method
    requiredFields
  }
}

{ 
  "input": {
  }
}

{
  "data": {
    "availableDeliveryMethods": [
      {
        "country": "AE",
        "currency": "AED",
        "method": "ACC_NO",
        "requiredFields": [
          "bic",
          "accountNo"
        ]
      },
      {
        "country": "AT",
        "currency": "EUR",
        "method": "IBAN",
        "requiredFields": [
          "bic",
          "iban"
        ]
      },
...

The response above means that if you want to send euros to Austria (AT) then you'd need a BIC (aka SWIFT) code and an IBAN.

List some of the delivery methods

const bodyJSON = {
  variables: {
    input: {
      country: "FR",
      currency: "EUR",
    },
  }, 
  query: `
query ($input: AvailableDeliveryMethodsInput!) {
  availableDeliveryMethods(input: $input) {
    country currency method requiredFields
  }
}`,
};

query($input: AvailableDeliveryMethodsInput!) {
  availableDeliveryMethods(input: $input) {
    country
    currency
    method
    requiredFields
  }
}

{
  "input": {
    "country": "FR", 
    "currency": "EUR" 
  }
}

{
  "data": {
    "availableDeliveryMethods": [
      {
        "country": "FR",
        "currency": "EUR",
        "method": "ACC_NO",
        "requiredFields": [
          "bic",
          "accountNo"
        ]
      },
      {
        "country": "FR",
        "currency": "EUR",
        "method": "IBAN",
        "requiredFields": [
          "bic",
          "iban"
        ]
      }
    ]
  }
}

The response above means that to send euros to France (FR) you have to have ether of:

• BIC and an account number, or

• BIC and an IBAN.

Query all deposits

const bodyJSON = {
  variables: {
    input: {
    },
  },
  query: `
query ($input: DepositQueryInput!) {
  deposits(input: $input) {
    id amount currency status statusMessage externalId externalReference
    subClient {
      id fullName status clientType
    }    
    createdAt
  }
}`,
};

query($input: DepositQueryInput!) {
  deposits(input: $input) {
    id
    amount
    currency
    status
    statusMessage
    externalId
    externalReference
    subClient {
      id
      fullName
      status
      clientType
    }
    createdAt
    # more fields available, see API schema
  }
}

{ 
  "input": {
  }
}

{
  "data": {
    "deposits": [
      {
        "id": "6053d4e0e3bc655e0598a742",
        "amount": 2000,
        "currency": "AUD",
        "status": "CONFIRMED",
        "statusMessage": "Transaction Confirmed",
        "externalId": "PR.1vcl",
        "externalReference": "FX1111",
        "subClient": null,
        "createdAt": "2021-03-18T22:32:01.010Z"
      },
      {
        "id": "6053d3319588389e1443587e",
        "amount": 40,
        "currency": "AUD",
        "status": "CONFIRMED",
        "statusMessage": "Transaction Confirmed",
        "externalId": "PR.1vci",
        "externalReference": "FX2121",
        "subClient": {
          "id": "5fb314cb9224595df522db61",
          "fullName": "John Doe",
          "status": "ACTIVE",
          "clientType": "INDIVIDUAL"
        },
        "createdAt": "2021-03-18T22:24:49.096Z"
      },
    ]
  }
}

Query deposit by ID

const bodyJSON = {
  variables: {
    input: "6053d4e0e3bc655e0598a742",
  },
  query: `
query ($input: ID) {  
  deposit(id: $input) {
    id 
    amount currency status statusMessage externalId externalReference createdAt
  }
}`,
};

query($input: ID) {
  deposit(id: $input) {
    id
    amount
    currency
    status
    statusMessage
    externalId
    externalReference
    createdAt
    # more fields available, see API schema
  }
}

{
  # there are more query parameters available, see the API schema
  "input": "6053d4e0e3bc655e0598a742"
}

{
  "data": {
    "deposit": {
      "id": "6053d4e0e3bc655e0598a742",
      "amount": 2000,
      "currency": "AUD",
      "status": "CONFIRMED",
      "statusMessage": "Transaction Confirmed",
      "externalId": "PR.1vcl",
      "externalReference": "KX23249",
      "createdAt": "2021-03-18T22:32:01.010Z"
    }
  }
}

Retrieving all your payments

const bodyJSON = {
  variables: {
    input: {
    },
  },
  query: `
query ($input: PaymentQueryInput!) {
  payments(input: $input) {   
    id fromCurrency toCurrency 
  }
}`,
};  

 query($input: PaymentQueryInput!) {
  payments(input: $input) {
    id
    fromCurrency
    toCurrency
    # there are many other properties
  }
}

 {
  "input": { 
  }
}

{
  "data": {
    "payments": [
      {
        "id": "5b04c62ec0bf606bf216ae21",
        "fromCurrency": "AUD",
        "toCurrency": "EUR"
      },
      {
        "id": "5b04c6bfc0bf606bf216af06",
        "fromCurrency": "AUD",
        "toCurrency": "USD"
      },
      {
        "id": "5b04c8e3c0bf606bf216b026",
        "fromCurrency": "EUR",
        "toCurrency": "AUD"
      }
    ]
  }
}

Retrieving some of your payments

const bodyJSON = {
  variables: {
    input: {
      statuses: "CLOSED",
      toCurrencies: ["EUR","USD"], 
    },
  },
  query: `
query ($input: PaymentQueryInput!) {
  payments(input: $input) {   
    id fromCurrency toCurrency 
  }
}`,
};    

  query($input: PaymentQueryInput!) {
  payments(input: $input) {
    id
    fromCurrency
    toCurrency
    # there are many other properties
  }
}

 {
  # there are more query parameters available, see the API schema
  "input": { 
    "statuses": "CLOSED",
    "toCurrencies": ["EUR","USD"]
  }
}

{
  "data": {
    "payments": [
      {
        "id": "5b04c62ec0bf606bf216ae21",
        "fromCurrency": "AUD",
        "toCurrency": "EUR"
      },
      {
        "id": "5b04c6bfc0bf606bf216af06",
        "fromCurrency": "AUD",
        "toCurrency": "USD"
      }
    ]
  }
}

Retrieving a single payment

const bodyJSON = {
  variables: {
    input: "5b04c62ec0bf606bf216ae21",
  },
  query: `
query ($input: ID) {  
  payment(id: $input) {
    status createdAt size
  }
}`,
};

query($input: ID) {
  payment(id: $input) {
    status
    createdAt
    size
    # there are many other properties
  }
}

{
  # there are more query parameters available, see the API schema
  "input": "5b04c62ec0bf606bf216ae21"
}

{
  "data": {
    "payment": {
      "status": "CLOSED",
      "createdAt": "2018-08-13T05:45:28.698Z",
      "size": 1000
    }
  }
}

You can disable and activate sub-clients. Deposits sent to a disabled sub-client will no longer be booked against your balance.

Disabling a sub-client

const bodyJSON = {
  variables: {
    input: "606128f24bf29139b2cf74ef",
  },
  query: `
mutation ($input: ID!) {
  disableSubClient(id: $input) {
    success code message 
    subClient {
      id status
    }
  }
}`,
};

mutation($input: ID!) {
  disableSubClient(id: $input) {
    success
    code
    message
    subClient {
      id
      status
    }
  }
}

{ 
   "input": "606128f24bf29139b2cf74ef"
}

{
  "data": {
    "disableSubClient": {
      "success": true,
      "code": "SUCCESS",
      "message": "Sub-client was successfully disabled",
      "subClient": {
        "id": "606128f24bf29139b2cf74ef",
        "status": "DISABLED"
      }
    }
  }
}

Activating a sub-client

const bodyJSON = {
  variables: {
    input: "606128f24bf29139b2cf74ef",
  },
  query: `
mutation ($input: ID!) {
  activateSubClient(id: $input) {
    success code message 
    subClient {
      id status
    }
  }
}`,
};

mutation($input: ID!) {
  activateSubClient(id: $input) {
    success
    code
    message
    subClient {
      id
      status
    }
  }
}

{ 
   "input": "606128f24bf29139b2cf74ef"
}

{
  "data": {
    "activateSubClient": {
      "success": true,
      "code": "SUCCESS",
      "message": "Sub-client was successfully activated",
      "subClient": {
        "id": "606128f24bf29139b2cf74ef",
        "status": "ACTIVE"
      }
    }
  }
}

Updating sub-clients

At this point, you can update the externalId property only because each sub-client has a set of linked domestic and international Virtual Account Numbers to send and receive funds.

const bodyJSON = { 
  variables: {
    id: "660fef8e1f3b5452bd6945ec",
    input: {
      externalId: "my_system_id_29f-ae0978b00d09e",
    },
  }, 
  query: `
mutation ($id: ID!, $input: UpdateSubClientInput!) {
  updateSubClient(id: $id, input: $input) {
    success code message
    subClient {
      id status externalId
    }
  }
}`,
};

mutation($id: ID!, $input: UpdateSubClientInput!) {
  updateSubClient(id: $id, input: $input) {
    success
    code
    message
    subClient {
      id
      status
      externalId
    }
  }
}

{ 
  "id": "660fef8e1f3b5452bd6945ec", 
  "input": {
    "externalId": "my_system_id_29f-ae0978b00d09e"
  }
}

{
  "data": {
    "updateSubClient": {
      "success": true,
      "code": "SUCCESS",
      "message": "Sub-client was successfully updated",
      "subClient": {
        "id": "660fef8e1f3b5452bd6945ec",
        "status": "ACTIVE",
        "externalId": "my_system_id_29f-ae0978b00d09e"
      }
    }
  }
}

Retrieving all your conversions

const bodyJSON = {
  variables: {
    input: {
    },
  },
  query: `
query ($input: ConversionQueryInput!) {
  conversions(input: $input) {   
    id fromCurrency toCurrency rate 
  }
}`,
};    

 query($input: ConversionQueryInput!) {
  conversions(input: $input) {
    id
    fromCurrency
    toCurrency
    rate
    # there are many other properties
  }
}

 {
  "input": { 
  }
}

{
  "data": {
    "conversions": [
      {
        "id": "6b04c62ec0bf606bf216ae21",
        "fromCurrency": "AUD",
        "toCurrency": "EUR",
        "rate": 0.71
      },
      {
        "id": "6b04c6bfc0bf606bf216af06",
        "fromCurrency": "AUD",
        "toCurrency": "USD",
        "rate": 0.70
      },
      {
        "id": "6b04c8e3c0bf606bf216b026",
        "fromCurrency": "EUR",
        "toCurrency": "AUD",
        "rate": 0.71
      }
    ]
  }
}

Retrieving some of your conversions

const bodyJSON = {
  variables: {
    input: {
      statuses: "CONVERTED",
      toCurrencies: ["EUR","USD"], 
    },
  },
  query: `
query ($input: ConversionQueryInput!) {
  conversions(input: $input) {   
    id fromCurrency toCurrency rate 
  }
}`,
};    

query($input: ConversionQueryInput!) {
  conversions(input: $input) {
    id
    fromCurrency
    toCurrency
    # there are many other properties
  }
}

{
  "input": { 
    "statuses": "CONVERTED",
    "toCurrencies": ["EUR","USD"]
  }
}

{
  "data": {
    "conversions": [
      {
        "id": "6833ad9b4e94acce5d4a031b",
        "fromCurrency": "AUD",
        "toCurrency": "USD"
      },
      {
        "id": "678a18bb2879c374b378ee71",
        "fromCurrency": "AUD",
        "toCurrency": "EUR"
      }
    ]
  }
}

Retrieving a single conversion by ID

const bodyJSON = {
  variables: {
    input: "6b04c62ec0bf606bf216ae21",
  },
  query: `
query ($input: ID) {  
  conversion(id: $input) {
    status createdAt fromAmount toAmount 
  }
}`,
};

query($input: ID) {
  conversion(id: $input) {
    status
    createdAt
    fromAmount
    toAmount
    # there are many other properties
  }
}

{
  "input": "6b04c62ec0bf606bf216ae21"
}

{
  "data": {
    "conversion": {
      "status": "CONVERTED",
      "createdAt": "2024-08-13T05:45:28.698Z",
      "fromAmount": 1000,
      "toAmount": 710.01
    }
  }
}

Consider requesting an indicative quote to understand the current currency trading rates before deciding to take action. Please be aware that market makers are not required to honor indicative quotes.

Paste this query to the API Playground to request an indicative quote.

const bodyJSON = {
  variables: {
    input: {
      fromCurrency: "AUD",
      toCurrency: "USD",
      size: "10000",
      currency: "AUD",
    },
  },
  query: `
query ($input: QuoteInput!) { 
  quote(input: $input) {   
    bid ask symbol timestamp inverted 
  }
}`,
};

query($input: QuoteInput!) {
  quote(input: $input) {
    bid
    ask
    symbol
    timestamp
    inverted
  }
}

{
  "input": { 
    "fromCurrency": "AUD", 
    "toCurrency": "USD", 
    "size": "10000", 
    "currency": "AUD"
  }
}

{
  "data": {
    "quote": {
      "bid": 0.61104,
      "ask": 0.62077,
      "symbol": "USDAUD",
      "timestamp": "2018-08-13T07:54:54.993Z",
      "inverted": true
    }
  }
}

In contrast to an indicative quote, a tradable quote is guaranteed by the market maker.

Paste this query to the GraphQL Playground to request a tradable quote. It is important to consider the expireAt date and time, and preserve the id of a tradable quote for future createPayment and createConversion calls.

const bodyJSON = {
  variables: {
    input: {
      fromCurrency: "AUD",
      toCurrency: "USD",
      size: "10000",
      currency: "AUD",
      tradable: true,
    },
  },
  query: `
query ($input: QuoteInput!) { 
  quote(input: $input) {   
    bid ask symbol timestamp inverted expireAt id
  }
}`,
};

query($input: QuoteInput!) {
  quote(input: $input) {
    bid
    ask
    symbol
    timestamp
    inverted
    expireAt
    id
  }
}

 {
  "input": { 
    "fromCurrency": "AUD", 
    "toCurrency": "USD", 
    "size": "10000", 
    "currency": "AUD",
    "tradeable": true 
  }
}

{
  "data": {
    "quote": {
      "bid": 0.61339,
      "ask": 0.63101,
      "symbol": "AUDUSD",
      "timestamp": "2025-03-04T01:53:08.829Z",
      "inverted": false,
      "expireAt": "2025-03-04T01:55:08.830Z",
      "id": "67c65d04e5086d18751617ba"
    }
  }
}

If your transaction is canceled by our Compliance team, the unique rejectCode and a corresponding standard statusMessage will be assigned to this transaction and sent to your application via proper webhook such as withdrawal_canceled to be used for a subsequent integration action such as field mapping or reconciliation.

Below is the latest list of our supported rejection codes and standard status messages. Please note, while the rejection codes are unique, you might see the corresponding free text status messages customized by our Compliance team for more accuracy and clarity of the information exchange.

Before doing any other API calls you have to obtain an auth token. It's a standard JWT token carrying the following payload:

The token lifetime is 4 hours at this time. We might change this value in the future.

To be more future-proof, it is recommended to parse the token payload and compare current time to the token's expiration time. JavaScript code:

Getting a token

1. After we enable you, go to the , click "DOCS" on the right to explore the possibilities.

2. Find there the login mutation. Execute it to obtain your access token. For example: mutation { login(input: {email: "YOUR_EMAIL" password: "YOUR_PWD"}) {token message} }

3. Click the "HTTP HEADERS" on the bottom and add this: {"authorization": "Bearer YOUR_TOKEN"}. Replace the YOUR_TOKEN with the token you just got.

4. Execute any other queries.

Here is an example of the login query.

If using then click the "HTTP HEADERS" on the bottom left and paste there the following (replace the YOUR_TOKEN with the value you have just received form the above mutation):

Affiliation

Clients that have contractual agreements with more than one subsidiary of Flash Payments, can use the optional field affiliation to control which account to log into.

The affiliation field accepts one of two constant values - FP_AUS or FP_LUX - which are passed unquoted.

If the affiliation value does not correspond to an existent account, authentication will fail with code UNREGISTERED even if an account exists with another affiliation and the credentials are correct.

If the user has multiple affiliations and the field affiliation is omitted, authentication will fail with code NEED_AFFILIATION.

Instructing Institution

Institution entity is a piece of information about the party who instructed you to make the withdrawal. This data is important for compliance within Australia. This is not the sender. If there is no other institution who has instructed this withdrawal, leave this blank and your own details will be used for compliance and auditing purposes.

Creating institutions

• via Flash Connect (you can copy an ID of an existing Institution).

• via API by invoking createInstitution mutation.

• by providing instructingInstitution object into createWithdrawal mutation.

Creating institution example

Retrieving all your withdrawals

const bodyJSON = {
  variables: {
    input: {
    },
  },
  query: `
query ($input: WithdrawalQueryInput!) {
  withdrawals(input: $input) {   
    id
    recipient {
     firstName lastName
    }
  }
}`,
};  

query($input: WithdrawalQueryInput!) {
  withdrawals(input: $input) {
    id
    recipient {
      firstName
      lastName
    } 
    # there are many other properties
  }
}

{ 
  "input": {
  }
}

{
  "data": {
    "withdrawals": [
      {
        "id": "5b04c62ec0bf606bf216ae21",
        "recipient": {
          "firstName": "John"
          "lastName": "Smith"
        }
      },
      {
        "id": "5b04c6bfc0bf606bf216af06",
        "recipient": {
          "firstName": "John"
          "lastName": "Smith"
        }
      },
      {
        "id": "5b04c8e3c0bf606bf216b026",
        "recipient": {
          "firstName": "John"
          "lastName": "Smith"
        }
      }
    ]
  }
}

Retrieving some of your withdrawals

const bodyJSON = {
  variables: {
    input: {
      statuses: "CONFIRMED",
      maxCreatedAt: "2020-01-29",
    },
  },
  query: `
query ($input: WithdrawalQueryInput!) {
  withdrawals(input: $input) {   
    id createdAt 
  }
}`,
};  

query($input: WithdrawalQueryInput!) {
  withdrawals(input: $input) {
    id
    createdAt 
    # there are many other properties
  }
}

{    
  # there are more query parameters available, see the API schema
  "input": {
    "statuses": "CONFIRMED",
    "maxCreatedAt": "2020-01-29"
  }  
}

{
  "data": {
    "withdrawals": [
      {
        "id": "5b04c62ec0bf606bf216ae21",
        "createdAt": "2020-01-17T07:21:20.247Z"
      },
      {
        "id": "5b04c6bfc0bf606bf216af06",
        "createdAt": "2018-08-13T05:45:28.698Z"
      }
    ]
  }
}

Retrieving a single withdrawal

const bodyJSON = {
  variables: {
    input: "5b04c62ec0bf606bf216ae21",
  },
  query: `
query ($input: ID) {  
  withdrawal(id: $input) {
    status createdAt amount
  }
}`,
};

query($input: ID) {
  withdrawal(id: $input) {
    status
    createdAt
    amount
    # there are many other properties
  }
}

{
  # there are more query parameters available, see the API schema
  "input": "5b04c62ec0bf606bf216ae21"
}

{
  "data": {
    "withdrawal": {
      "status": "CONFIRMED",
      "createdAt": "2020-01-17T07:21:20.247Z",
      "amount": 1000
    }
  }
}

Available queries

Query for a single sub-client

const bodyJSON = {
  variables: {
    id: "606d28675a2d931bc925fec2",
      input: {
        currencies: ["EUR","USD","HKD","CNY"],
      },
  },
  query: `
query ($id: ID!, $input: FundingAccountQueryInput!) {
  subClient(id: $id) {
    id fullName legalName tradingAsNam clientType status 
    primaryContact {
      firstName middleName lastName email dob mobile
    }
    address {
      building street suburb state country postcode
    }
    postalAddress {
      building street suburb state country postcode
    } 
    businessNumber bsb accountNo externalId
    fundingAccounts(input: $input) {
      iban accountNo bic currency externalReference
    }
  }
}`,
};

query($id: ID!, $input: FundingAccountQueryInput!) {
  subClient(id: $id) {
    id
    fullName
    legalName
    tradingAsName
    clientType
    status
    primaryContact {
      firstName
      middleName
      lastName
      email
      dob
      mobile
    }
    address {
      building
      street
      suburb
      state
      country
      postcode
    }
    postalAddress {
      building
      street
      suburb
      state
      country
      postcode
    }
    businessNumber
    bsb
    accountNo
  	externalId
    fundingAccounts(input: $input) {
      iban
      accountNo
      bic
      currency
      externalReference
    }
  }
}

{ 
  "id": "606d28675a2d931bc925fec2",
  "input": {
    "currencies": ["EUR", "USD", "HKD", "CNY"] 
  }
}

{
  "data": {
    "subClient": {
      "id": "606d28675a2d931bc925fec2",
      "fullName": "ACME Corp",
      "legalName": "ACME Corp",
      "tradingAsName": null,
      "clientType": "COMPANY",
      "status": "ACTIVE",
      "primaryContact": {
        "firstName": "John",
        "middleName": null,
        "lastName": "Smith",
        "email": "[email protected]",
        "dob": "1980-12-12",
        "mobile": "+61 422 832 849"
      },
      "address": {
        "building": "25",
        "street": "Moore St",
        "suburb": "Waterloo",
        "state": "NSW",
        "country": "AU",
        "postcode": "2017"
      },
      "postalAddress": {
        "building": "25",
        "street": "Moore St",
        "suburb": "Waterloo",
        "state": "NSW",
        "country": "AU",
        "postcode": "2017"
      },
      "businessNumber": "91383840265",
      "bsb": "802919",
      "accountNo": "1066419",
      "externalId": "991188227733"
    }
  }
}

Query for multiple sub-clients

const bodyJSON = {
  variables: {
    input: {
    },
  },
  query: `
query ($input: SubClientQueryInput!) {
  subClients(input: $input) {   
    id fullName legalName clientType status businessNumber
    bsb accountNo externalId
  }
}`,
};  

query($input: SubClientQueryInput!){
  subClients(input: $input) {
    id
    fullName
    legalName
    clientType
    status
    businessNumber
    bsb
    accountNo
    externalId
    # any other set of properties
  }
}

 {
 "input": {
  }
}

{
  "data": {
    "subClients": [
      {
        "id": "5fb314cb9224595df522db61",
        "fullName": "Richard Smith",
        "legalName": null,
        "clientType": "INDIVIDUAL",
        "status": "ACTIVE",
        "businessNumber": null,
        "bsb": "802919",
        "accountNo": "1963041",
        "externalId": null
      },
      {
        "id": "60612f00a4d7dd5c96e37676",
        "fullName": "ABC Capital",
        "legalName": "ABC Co",
        "clientType": "COMPANY",
        "status": "ACTIVE",
        "businessNumber": "839399923932",
        "bsb": "802919",
        "accountNo": "1914920",
        "externalId": null
      }
    ]
  }
}

Query for multiple sub-clients with filters

const bodyJSON = {
  variables: {
    input: {
      clientType: "INDIVIDUAL",
      status: "ACTIVE",
      firstName: "John",
      lastName: "Smith",
      address: { 
        country: "AU", 
      },
    },
  },
  query: `
query ($input: SubClientQueryInput!) {
  subClients(input: $input) {   
    id fullName clientType status 
    primaryContact {
      firstName lastName
    }
    address {
      country
    }
  }
}`,
};  

query($input: SubClientQueryInput!){
  subClients(input: $input) {
    id
    fullName
    clientType
    status   
    primaryContact {
      firstName
      lastName
    }
    address {
      country
    }
    # any other set of properties
  }
}

{   
# more filters available, see SubClientQueryInput in API schema
  "input": {
    "clientType": "INDIVIDUAL",
    "status": "ACTIVE",
    "firstName": "John",
    "lastName": "Smith",
    "address": { 
      "country": "AU" 
    }
  }
}

{
  "data": {
    "subClients": [
      {
        "id": "5fb314cb9224595df522db61",
        "fullName": "John Smith",
        "clientType": "INDIVIDUAL",
        "status": "ACTIVE",
        "primaryContact": {
          "firstName": "John",
          "lastName": "Smith"
        },
        "address": {
          "country": "AU"
        }
      }
    ]
  }
}

Some customers can automatically receive funds from overseas. Meaning, if we detect an overseas deposit to the Flash Payments controlled bank account(s) then we can automatically create an inbound payment, convert funds, and top up your Flash Payments balance with AUD.

Here is how it looks step by step.

1. We would need to enable the foreign currency auto-receiving feature for you.

2. You, or your Sub-client, would have a special bank account in, say, SEPA zone. Find the details below.

   • The account number and payment reference depends on the currency and country you wish to deposit to. E.g. the EUR currency account is usually a British IBAN (starts with "GB").

3. You, or your Sub-client, would deposit money to it. Make sure to submit the exact payment reference we told you! Otherwise, your funds will be returned.

4. The Flash Payments would detect the account funding event and automatically create a EUR->AUD payment for you.

5. You would receive at least two webhook notifications - payment_created and payment_complete.

6. Your Flash Payments AUD balance would increase accordingly.

To find which foreign currency bank account you would need to deposit to, please go to the FlashConnect and find there the list of inbound currencies we support and the corresponding bank account numbers. It's called the "Funding Accounts" throughout the user interface.

To find out the Funding Accounts via API please use the fundingAccounts query.

You should deposit your foreign currency to:

const bodyJSON = {
  variables: {
    input: {
      currencies: ["EUR","USD","HKD","CNY"],
      },
  },
  query: `
query ($input: FundingAccountQueryInput!) {
  fundingAccounts(input: $input) {
    iban accountNo accountName accountAddress bic currency externalReference
  }
}`,
};

  query($input: FundingAccountQueryInput!) {
  fundingAccounts(input: $input) {
    iban
    accountNo
    accountName
    accountAddress
    bic
    currency
    externalReference
  }
}

 {
  "input": { 
    "currencies": ["EUR", "USD", "HKD", "CNY"] 
  }
}

{
  "data": {
    "fundingAccounts": [
      {
        "iban": "GB91 BARC 2006 0565 4685 66",
        "accountNo": "65468566",
        "bic": "BARCGB22",
        "currency": "USD",
        "externalReference": "191127-99999"
      },
      {
        "iban": "GB05 BARC 2006 0574 7412 77",
        "accountNo": "74741277",
        "bic": "BARCGB22",
        "currency": "EUR",
        "externalReference": "191127-99999"
      },
      {
        "iban": null,
        "accountNo": "87135588",
        "bic": "BARCGB22",
        "currency": "CNY",
        "externalReference": "191127-99999"
      },
      {
        "iban": "GB87 BARC 2006 0546 9946 00",
        "accountNo": "46994600",
        "bic": "BARCGB22",
        "currency": "HKD",
        "externalReference": "191127-99999"
      }
    ]
  }
}

Your sub-clients should deposit their foreign currency to:

const bodyJSON = {
  variables: {
    sc: {
      externalId: "991188227733",
    },
    fa: {
      currencies: ["EUR","USD","CNY"],
    },
  },
  query: `
query ($sc: SubClientQueryInput!, $fa: FundingAccountQueryInput!) {
  subClients(input: $sc) {
    id externalId 
    fundingAccounts(input: $fa) {
      iban accountNo accountName accountAddress bic currency externalReference
    }
  }
}`,
};

query($sc: SubClientQueryInput!, $fa: FundingAccountQueryInput!) {
  subClients(input: $sc) {
    id
    externalId
    fundingAccounts(input: $fa) {
      iban
      accountNo
      accountName
      accountAddress
      bic
      currency
      externalReference
    }
  }
}

 {
  "sc": { 
    "externalId": "991188227733" 
  },
  "fa": {
    "currencies": ["EUR", "USD", "CNY"] 
  }
}

{
  "data": {
    "subClients": [
      {
        "id": "60a1e9e76eaedbf66964a323",
        "externalId": "991188227733",
        "fundingAccounts": [
          {
            "iban": "GB91 BARC 2006 0565 4685 66",
            "accountNo": "65468566",
            "bic": "BARCGB22",
            "currency": "USD",
            "externalReference": "210616-99999"
          },
          {
            "iban": "GB05 BARC 2006 0574 7412 77",
            "accountNo": "74741277",
            "bic": "BARCGB22",
            "currency": "EUR",
            "externalReference": "210616-99999"
          },
          {
            "iban": null,
            "accountNo": "87135588",
            "bic": "BARCGB22",
            "currency": "CNY",
            "externalReference": "210616-99999"
          },
        ]
      }
    ]
  }
}

To make a payment from AUD to a different currency, you need to execute the createPayment mutation as below.

Recipient - recipientId

You should and send us their ID.

Sender - senderId or subClientId , or neither

In the above createPayment example, you had to and use senderId as an input. Alternatively, if your account is configured to make FX payments on behalf of your , you may provide us with the sub-client ID, and the FX payment created will be linked to that sub-client. In this case, the subClientId will be used as the sender and will be reported to the government.

To use subClientId as the sender for your payments, please execute the createPayment mutation as below.

If your company is the ultimate sender for an FX payment, you can skip both the senderId and subClientId. In this situation, we will use your company’s Flash account as the sender for the payment. Please note that a new sender record will not be created in this case.

Please execute the following createPayment mutation to use your company's Flash account details as sender.

Callback (aka ) URI

We recommend against continuous polling for payment status changes. Instead, please use callbackUri.

The optional callbackUri will be invoked several times during the processing of a payment. These callbacks will usually occur soon (within several seconds) after the initial create payment call - but may be delayed in some cases. The example JSON payloads can be found on the .

Please note that toAmount (or fromAmount) and other fluctuating payment properties can change during payment execution.