Split API v1.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Split allows you to make, get and manage payments using nothing but bank accounts.

It is important to understand that there are 2 main ways Split can be used for maximum flexibility:

Between Split accounts.
Between a Split account and anyone.

Due to the above, certain endpoints and techniques will differ slightly depending on who you are interacting with. You can find more on this in the Making payments and Getting paid guides.

Conventions

Authentication is performed using OAuth2. See the Get started and Authentication & Authorisation guides for more.
All communication is via https.
Production API: https://api.split.cash/.
Production UI: https://go.split.cash/.
Sandbox API: https://api-sandbox.split.cash/.
Sandbox UI: https://go-sandbox.split.cash/.
Data is sent and received as JSON.
Currencies are represented by 3 characters as defined in ISO 4217.
Dates & times are returned in UTC using ISO 8601 format with second accuracy. With requests, when no TZ is supplied, the configured TZ of the authenticated user is used.
Amounts are always in cents with no decimals unless otherwise stated.

Guides

Try it out

The best way to familiarise yourself with our API is by interacting with it.

Prefer a screencast? We've got you covered: https://vimeo.com/246203244.

We've preloaded a collection of all our endpoints for you to use in Postman.

Before you start, load up our API collection:

Okay, lets get things setup!

Create a Split account

If you haven't already, you'll want to create a sandbox Split account at https://go-sandbox.split.cash
Register your application with Split

Sign in and create an OAuth2 application: https://go-sandbox.split.cash/oauth/applications.
In Postman, setup your environment variables

Click on Manage Environments

We've included the Split Payments Public Sandbox environment to get you started. Go ahead an click on it.

Using the details from the OAuth2 app you created earlier, fill in the oauth2_application_id & oauth2_secret fields.
Setup the authorization

Click on the Authorization tab and select OAuth 2.0

Click the Get New Access Token button

Fill in the OAuth2 form as below:
Get authorised

Click Request Token and wait a few seconds and a browser window will popup

Sign in with your Split account (or any other Split account you want to authorise).

Click Authorise to allow the app to access the signed in account. Once complete, Postman will automatically exchange the authorisation code it received from Split for the access_token/refresh_token pair. It will then store the access_token/refresh_token for you to use in subsequent API requests. The access_token effectively allows you to send requests via the API as the user who provided you authorisation.
You're now ready to use the API

Select an endpoint from the Split collection from the left hand side menu. Before you send an API request ensure you select your access token and Postman will automatically add it to the request header.

Get started

This guide will help you setup your OAuth2 app in order to get authenticated & authorised to communicate with the Split API.

Before you start:

Often times you'll want to grant your own app access to itself so that you can access the API on your own account. We use the term user below but the user can be a third party or the same user that owns the OAuth2 application.
As noted below, the access token expires every 2 hours. To get a new access token without going through steps 1 to 4 again, use the refresh grant strategy to swap a refresh token for a new access token.

Create a Split account

If you haven't already, you'll want to create a sandbox Split account at https://go-sandbox.split.cash.

Register your application with Split

Once you've got your account up and running, sign in and create an OAuth2 profile for your application: https://go-sandbox.split.cash/oauth/applications

Parameter	Description
Name	The name of your application. When using the the Authorisation Grant Flow, users will see this name as the application requesting access to their account.
Redirect URI	Set this to your application's endpoint charged with receiving the authorisation code.

Obtain an authorisation code

Construct the initial URL the user will need to visit in order to grant your application permission to act on his/her behalf. The constructed URL describes the level of permission (scope), the application requesting permission (client_id) and where the user gets redirected once they've granted permission (redirect_uri).

The URL should be formatted to look like this: https://go-sandbox.split.cash/oauth/authorize?response_type=code&client_id={client_id}&redirect_uri={redirect_uri}&scope={scope}

Parameter	Description
`response_type`	Always set to `code`
`client_id`	This is your `Application ID` as generated when you registered your application with Split
`redirect_uri`	URL where the user will get redirected along with the newly generated authorisation code
`scope`	The scope of permission you're requesting

Exchange the authorisation code for an access token

When the user visits the above-mentioned URL, they will be presented with a Split login screen and then an authorisation screen:

After the user has authorised your application, they will be returned to your application at the URL specified in redirect_uri along with the code query parameter as the authorisation code.

Finally, the authorisation code can than be exchanged for an access token and refresh token pair by POSTing to: https://go-sandbox.split.cash/oauth/token

Parameter	Description
`grant_type`	Set to `authorization_code`
`client_id`	This is your `Application ID` as generated when you registered your application with Split
`client_secret`	This is your `Secret` as generated when you registered your application with Split
`code`	The authorisation code returned with the user
`redirect_uri`	Same URL used in step 3

Wrap-up

Now that you have an access token and refresh token, you can interact with the Split API as the user related to the access token. To do so, you must simply append the access token to the header of any API request: Authorization: Bearer {access_token}

Authentication and Authorisation

Split uses OAuth2 over https to manage authentication and authorisation.

OAuth2 is a protocol that lets external applications request permission from another Split user to send requests on their behalf without getting their password. This is preferred over Basic Authentication because access tokens can be limited by scope and can be revoked by the user at any time.

New to OAuth2? DigitalOcean has a fantastic 5 minute introduction to OAuth2.

We currently support the authorisation code and refresh token grants.

Authorisation Code Grant

This type of grant allows your application to act on behalf of a user. If you've ever used a website or application with your Google, Twitter or Facebook account, this is the grant being used.

See the Get Started guide for step by step details on how to use this grant.

Refresh Token Grant

Code sample

curl -F "grant_type=refresh_token" \
     -F "client_id={{oauth2_application_id}}" \
     -F "client_secret={{oauth2_application_secret }}" \
     -F "refresh_token={{refresh_token}}" \
     -X POST https://go-sandbox.split.cash/oauth/token

Example response

{
    "access_token": "ad0b5847cb7d254f1e2ff1910275fe9dcb95345c9d54502d156fe35a37b93e80",
    "token_type": "bearer",
    "expires_in": 7200,
    "refresh_token": "cc38f78a5b8abe8ee81cdf25b1ca74c3fa10c3da2309de5ac37fde00cbcf2815",
    "scope": "public"
}

When using the authorisation code grant above, Split will return a refresh token along with the access token. Access tokens are short lived and last 2 hours but refresh tokens do not expire.

When the access token expires, instead of sending the user back through the authorisation flow you can use the refresh token to retrieve a new access token with the same permissions as the old one.

The refresh_token gets regenerated and sent alongside the new access_token. In other words, refresh_tokens are single use so you'll want to store the newly generated refresh_token everytime you use it to get a new acccess_token

Making payments

In order to payout funds, you'll be looking to use the Payments endpoint. Whether you're paying out another Split account holder or anyone, the process is the same:

Add the recipient to your Contacts: Split Contact or Anyone Contact
Make the Payment to your Contact.

Common use cases:

Automated payout disbursement (Referal programs, net/commission payouts, etc...)

Getting paid

There are 2 ways to get paid:

POSTing a Payment Request

Provides the ability to send a Payment Request (get paid) to any Contact that is either:

A Split Contact (A bank account owner that has a Split account); or
An Anyone Contact (A bank account owner that is not registered with Split) with an accepted Agreement in place.

For a Split Contact:

They will receive a request that they must approve via the Split UI or API in order for the funds to flow from their bank account to yours.
To automate the Payment Request approval, process you must first enter into an Agreement with the Split Contact. Once the Agreement is accepted, any future Payment Request will be automatically approved and processed per the Agreement terms.

For an Anyone Contact:

To send a Payment Request using the API to an Anyone Contact, you must first have an accepted Agreement with them . To do so, you can send them an Open Agreement link or Unassigned Agreement link for them to elect & verify their bank account and accept the Agreement.

Common use cases:

Subscriptions
On-account balance payments
Bill smoothing
Repayment plans

Example flow embedding an Open Agreement link using an iFrame in order to automate future Payment Request approvals:

Provides the ability to get paid once-off by a anyone whether they are a Split account holder or not.

Usage notes:

Utilise a customisable hosted Payment Request form that takes care of everything from confirming the payer's bank account access to the transfer of funds.
The Open Payment Request link can be shared and sit as a secure form either outside your app or embeded within via iframe with the ability to whitelabel.
The URL for the form contains all the customisation parameters enabling you to generate the form on the fly.

Common use cases:

Online or offline purchases (eCommerce, fundraiser, etc...)
Invoice payment
Group funding (paying for a restaurant bill)

Example flow embedding the Open Payment Request link using an iFrame:

Idempotent requests

Example response

{
  "errors": [
    {
      "title": "Duplicate idempotency key",
      "detail": "A resource has already been created with this idempotency key",
      "links": {
        "about": "https://docs.split.cash/"
      },
      "meta": {
        "resource_ref": "PB.1a4"
      }
    }
  ]
}

The Split API supports idempotency for safely retrying requests without accidentally performing the same operation twice. For example, if a Payment is POSTed and a there is a network connection error, you can retry the Payment with the same idempotency key to guarantee that only a single Payment is created.

To perform an idempotent request, provide an additional Idempotency-Key: <key> header to the request. You can pass any value as the key but we suggest that you use V4 UUIDs or another appropriately random string.

Keys expire after 24 hours. If there is a subsequent request with the same idempotency key within the 24 hour period, we will return a 409 Conflict.

The meta.resource_ref value is the reference of the resource that was previously created with the conflicting idempotency key.
The Idempotency-Key header is optional but recommended.
Only the POST action for the Payments, Payment Requests, Refunds, Refund Requests support the use of the Idempotency-Key.
Endpoints that use the GET or DELETE actions are idempotent by nature.

Speeding up onboarding

Consider the following scenario:

Split is integrated in your application to handle payments.
A customer would like to use Split but does not yet have Split account.
You already have some information about this customer.

Given the above, in a standard implementation where a customer enables/uses Split within your application, these are the steps they would follow:

Click on some sort of button within your app to use Split.
They get redirected to the Split sign in page (possibly via a popup or modal).
Since they don't yet have a Split account, they would click on sign up.
They would fill in all their signup details and submit.
They would be presented with the authorisation page.
They would click the "Authorise" button and be redirected to your app.

Whilst not too bad, we can do better!

In order to speed up the process, we allow query string params to be appended to the authorisation URL. For instance, if we already have some information about the customer and know they probably don't have a Split account, we can embed this information in the authorisation URL.

Supported query string parameters

Parameter	Description
`landing`	Accepted values: `business_sign_up` or `personal_sign_up`. What page the user should see first if not already signed in. Default is the sign in page.
`nickname`	Only letters, numbers, dashes and underscores are permitted. This will be used to identify the account in Split.
`name`	Business account only. Business name.
`abn`	Business account only. Business ABN.
`phone`	Business account only. Business phone number.
`street_address`
`suburb`
`state`	See the sign up page for accepted values
`postcode`
`first_name`
`last_name`
`mobile_phone`
`email`

All values should be URL encoded.

As an example, the following authorisation URL would display the personal sign up & prefill the first name field with George: https://go-sandbox.split.cash/oauth/authorize?response_type=code&client_id=xxx&redirect_uri=xxx&scope=xxx&landing=personal_sign_up&first_name=George

You can also pass the values directly to the sign up page outside of the OAuth2 authorisation process. Click on the following link to see the values preloaded: https://go-sandbox.split.cash/business/sign_up?name=GeorgeCo&nickname=georgeco&first_name=George.

Testing details

When using any of our hosted solutions (Payment Requests, Open Agreements or Unassigned Agreements) you may want to test the Instant Account Verification (IAV) process where we accept online banking credentials to validate bank account access. To do so, you can use the following credentials:

Login	Password
`gavinBelson`	`hooli2016`
`jared`	`django`
`richard`	`tabsnotspaces`

Configuration

Scopes

Scopes define the level of access granted via the OAuth2 authorisation process. As a best practice, only use the scopes your application will require.

Scope	Description
`public`	View user's public information
`agreements`	Manage user's Agreements
`bank_accounts`	Manage user's Bank Accounts
`contacts`	Manage user's Contacts
`open_agreements`	Manage user's Open Agreements
`payments`	Manage user's Payments
`payment_requests`	Manage user's Payment Requests
`refund_requests`	Manage user's Refund Requests
`refunds`	Manage user's Refunds
`transactions`	Access user's Transactions

Pagination

Example response header

Link: <http://api-sandbox.split.cash/contacts?page=5>; rel="last", <http://api-sandbox.split.cash/contacts?page=2>; rel="next"
Per-Page: 25
Total: 5

All collections are paginated to 25 items by default and the pagination information may be found in the response header. You can customise the pagination by appending ?per_page=x and/or ?page=x to the endpoint URL.

Remitter

Example request

{
  "...": "...",
  "metadata": {
   "remitter": "CustomRem"
   }
}

You can elect to assign a remitter name on a per-request basis when submitting Payments & Payment Requests. Simply append the remitter key and a value within the metadata key.

For Payments, the party being credited will see the designated remitter name along the entry on their bank statement.
For Payment Requests, the party being debited will see the designated remitter name along the entry on their bank statement.

Webhooks

Example response

{
  "event": {
    "type": "object.action",
    "at": "yyyy-mm-ddThh:mm:ssZ",
    "who": {
      "account_id": "x",
      "bank_account_id": "x"
    }
  },
  "data": [
    {
      // The data section will follow the same type of structure
      // as the event type it is representing. For example, if the
      // event type was "debit.scheduled", the data representation
      // structure would be that of a debit object. Too see what a
      // debit object structure looks like, see the Transactions
      // section.
    }
  ]
}

We support two main categories of webhooks:

Owner: These webhooks are managed by the owner of the Split account and only report on events owned by the Split account.
App: These webhooks are managed by the Split OAuth2 application owner and will report on events relating to any authorised Split account (limited by scope).

All events posted to the designated URL fit the same structure.

Agreements

Split Agreements are managed on a per Contact basis and allow two parties to agree on terms for which future Payment Requests will be auto-approved.

Agreement are unidirectional. In other words, if both parties wish for auto-approved Payment Requests, they must each propose an Agreement to the other.

Direction

Agreements are therefore broken up by direction:

Incoming: Agreement received from another Split account
Outgoing: Agreement sent to another Split account

Lifecycle

An Agreement can have the following statuses:

Status	Description
`proposed`	Waiting for the Agreement to be accepted or declined.
`accepted`	The Agreement have been accepted and is active.
`cancelled`	The Agreement has been cancelled (The initiator or authoriser can cancel an Agreement).
`declined`	The Agreement has been declined.

Propose an Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/agreements \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/agreements', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/agreements', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/agreements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /agreements

Propose an Agreement to another Split Contact

You can set any of the term metrics to null if you wish them to not have a limit.

Body parameter

{
  "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	ProposeAgreementRequest	true	No description
» authoriser_id	body	string	true	The Contact's account ID (`Contact.data.account.id`)
» terms	body	Terms	true	Terms
»» per_payout	body	PerPayout	true	No description
»»» min_amount	body	number	false	Minimum amount in cents a PR can be in order to be auto-approved
»»» max_amount	body	number	false	Maximum amount in cents a PR can be in order to be auto-approved
»» per_frequency	body	PerFrequency	true	No description
»»» days	body	number	false	Amount of days to apply against the frequency
»»» max_amount	body	number	false	Maximum amount in cents the total of all PRs can be for the duration of the frequency

Example responses

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	ProposeAgreementResponse

Approve an Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/agreements/{agreement_ref}/accept \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/agreements/{agreement_ref}/accept', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/agreements/{agreement_ref}/accept', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/agreements/{agreement_ref}/accept", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/{agreement_ref}/accept',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /agreements/{agreement_ref}/accept

Approve an incoming Agreement

Parameters

Parameter	In	Type	Required	Description
agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "accepted",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ApproveAgreementResponse

Decline and Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/agreements/{agreement_ref}/decline \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/agreements/{agreement_ref}/decline', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/agreements/{agreement_ref}/decline', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/agreements/{agreement_ref}/decline", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/{agreement_ref}/decline',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /agreements/{agreement_ref}/decline

Decline an incoming Agreement

Parameters

Parameter	In	Type	Required	Description
agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "declined",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	DeclineAgreementResponse

Get an Agreement

Code samples

curl -X GET https://api-sandbox.split.cash/agreements/{agreement_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/agreements/{agreement_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/agreements/{agreement_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/agreements/{agreement_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/{agreement_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /agreements/{agreement_ref}

Get a single Agreement by its reference

Parameters

Parameter	In	Type	Required	Description
agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "approved",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetAgreementResponse

Cancel an Agreement

Code samples

curl -X DELETE https://api-sandbox.split.cash/agreements/{agreement_ref} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/agreements/{agreement_ref}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/agreements/{agreement_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/agreements/{agreement_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/{agreement_ref}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /agreements/{agreement_ref}

An Agreement can be cancelled by the initiator at any time whilst the authoriser (Agreement recipient) can only cancel a previously accepted Agreement.

Parameters

Parameter	In	Type	Required	Description
agreement_ref	path	string	true	Single value, exact match

Responses

Status	Meaning	Description	Schema
204	No Content	No Content	None

List incoming Agreements

Code samples

curl -X GET https://api-sandbox.split.cash/agreements/incoming \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/agreements/incoming', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/agreements/incoming', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/agreements/incoming", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/incoming',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /agreements/incoming

By default, all incoming Agreements will be returned. You can apply filters to your query to customise the returned Agreements.

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match
initiator_id	query	string	false	Initiator ID (`Contact.data.account.id`), single value, exact match
status	query	array[string]	false	Multiple values, exact match

Enumerated Values

Parameter	Value
status	proposed
status	accepted
status	declined
status	cancelled

Example responses

{
  "data": [
    {
      "ref": "A.2",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
      "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
      "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": 1
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      }
    },
    {
      "ref": "A.1",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "56df206a-aaff-471a-b075-11882bc8906a",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-16T22:51:48Z",
      "terms": {
        "per_payout": {
          "max_amount": 5000,
          "min_amount": 0
        },
        "per_frequency": {
          "days": "1",
          "max_amount": 10000
        }
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListIncomingAgreementsResponse

List outgoing Agreements

Code samples

curl -X GET https://api-sandbox.split.cash/agreements/outgoing \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/agreements/outgoing', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/agreements/outgoing', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/agreements/outgoing", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/agreements/outgoing',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /agreements/outgoing

By default, all outgoing Agreements will be returned. You can apply filters to your query to customise the returned Agreements.

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match
authoriser_id	query	string	false	Authoriser ID (`Contact.data.account.id`), single value, exact match
status	query	array[string]	false	Exact match

Enumerated Values

Parameter	Value
status	proposed
status	accepted
status	declined
status	cancelled

Example responses

{
  "data": [
    {
      "ref": "A.4",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": 1
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      }
    },
    {
      "ref": "A.3",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "56df206a-aaff-471a-b075-11882bc8906a",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-16T22:51:48Z",
      "terms": {
        "per_payout": {
          "max_amount": 5000,
          "min_amount": 0
        },
        "per_frequency": {
          "days": "1",
          "max_amount": 10000
        }
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListOutgoingAgreementsResponse

Bank Accounts

Your currently linked up bank accounts.

List all Bank Accounts

Code samples

curl -X GET https://api-sandbox.split.cash/bank_accounts \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/bank_accounts', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/bank_accounts', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/bank_accounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/bank_accounts',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /bank_accounts

By default, all Bank Accounts will be returned. There can currently be only 1 active bank account.

Example responses

{
  "data": [
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "branch_code": "493192",
      "bank_name": "National Australia Bank",
      "account_number": "3993013",
      "status": "active"
    },
    {
      "id": "56df206a-aaff-471a-b075-11882bc8906a",
      "branch_code": "302193",
      "bank_name": "National Australia Bank",
      "account_number": "119302",
      "status": "removed"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListAllBankAccountsResponse

Contacts

Your Contacts form an address book of Split accounts and non-Split accounts (Anyone accounts) with whom you can interact. In order to initiate any type of transaction you must first have the party in your Contact list.

There are a few IDs supplied within a Contact's response:

data.id represents the Contact resource.
data.bank_account.id represents the Contact's bank account and is used when creating Payments or Payment Requests.
data.account.id represents the Contact's Split account and is used when proposing Agreements.

Add a Split Contact

Code samples

curl -X POST https://api-sandbox.split.cash/contacts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "nickname": "outstanding_tours"
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "nickname": "outstanding_tours"
}'

result = RestClient.post 'https://api-sandbox.split.cash/contacts', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/contacts', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/contacts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "nickname": "outstanding_tours"
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /contacts

Add a Split Contact

Body parameter

{
  "nickname": "outstanding_tours"
}

Parameters

Parameter	In	Type	Required	Description
body	body	AddASplitContactRequest	true	No description
» nickname	body	string	true	Split account nickname

Example responses

{
  "data": {
    "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
    "name": "Outstanding Tours Pty Ltd",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "verified"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	AddASplitContactResponse
404	Not Found	Not Found	None

List all Contacts

Code samples

curl -X GET https://api-sandbox.split.cash/contacts \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/contacts', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/contacts', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/contacts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /contacts

By default, all Contacts will be returned. You can apply filters to your query to customise the returned Contact list.

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match
account_id	query	string	false	Single value, string search
name	query	string	false	Single value, string search
nickname	query	string	false	Single value, string search
bank_account_id	query	string	false	Single value, exact match
bank_account_branch_code	query	string	false	Single value, exact match
bank_account_account_number	query	string	false	Single value, exact match

Example responses

{
  "data": [
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "name": "Outstanding Tours Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": "095c5ab7-7fa8-40fd-b317-cddbbf4c8fbc",
        "account_number": "494307",
        "branch_code": "435434",
        "bank_name": "National Australia Bank",
        "state": "verified"
      },
      "account": {
        "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
        "nickname": "outstanding_tours",
        "abn": "123456789",
        "name": "Outstanding Tours Pty Ltd"
      }
    },
    {
      "id": "49935c67-c5df-4f00-99f4-1413c18a89a0",
      "name": "Adventure Dudes Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": "861ff8e4-7acf-4897-9e53-e7c5ae5f7cc0",
        "account_number": "4395959",
        "branch_code": "068231",
        "bank_name": "National Australia Bank",
        "state": "verified"
      },
      "account": {
        "id": "362f7fe8-4af2-4902-b3d7-b5ab704ef2e7",
        "nickname": "adventure_dudes",
        "abn": "126754389",
        "name": "Adventure Dudes Pty Ltd"
      }
    },
    {
      "id": "eb3266f9-e172-4b6c-b802-fe5ac4d3250a",
      "name": "Surfing World Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": null,
        "account_number": null,
        "branch_code": null,
        "bank_name": null,
        "state": "disabled"
      },
      "account": {
        "id": "a31dc907-9c7a-4736-84c9-1149cf03de42",
        "nickname": "surfing_world",
        "abn": "295443789",
        "name": "Surfing World Pty Ltd"
      }
    },
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "name": "Hunter Thompson",
      "email": "[email protected]",
      "type": "anyone",
      "bank_account": {
        "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
        "account_number": "13048322",
        "branch_code": "123456",
        "bank_name": "National Australia Bank",
        "state": "pending_verification"
      },
      "anyone_account": {
        "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListAllContactsResponse

Add an Anyone Contact

Code samples

curl -X POST https://api-sandbox.split.cash/contacts/anyone \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "name": "Hunter Thompson",
  "email": "[email protected]",
  "branch_code": "123456",
  "account_number": "13048322"
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "name": "Hunter Thompson",
  "email": "[email protected]",
  "branch_code": "123456",
  "account_number": "13048322"
}'

result = RestClient.post 'https://api-sandbox.split.cash/contacts/anyone', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/contacts/anyone', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/contacts/anyone", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "name": "Hunter Thompson",
  "email": "[email protected]",
  "branch_code": "123456",
  "account_number": "13048322"
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts/anyone',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /contacts/anyone

When you want to pay somebody that doesn't have a Split account, you can add them as an Anyone Contact.

Body parameter

{
  "name": "Hunter Thompson",
  "email": "[email protected]",
  "branch_code": "123456",
  "account_number": "13048322"
}

Parameters

Parameter	In	Type	Required	Description
body	body	AddAnAnyoneContactRequest	true	No description
» name	body	string	true	The name of the Contact
» email	body	string	true	The email of the Contact
» branch_code	body	string	true	The bank account BSB of the Contact
» account_number	body	string	true	The bank account number of the Contact

Example responses

{
  "data": {
    "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
    "name": "Hunter Thompson",
    "email": "[email protected]",
    "type": "anyone",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "13048322",
      "branch_code": "123456",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "anyone_account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	AddAnAnyoneContactResponse

Get a Contact

Code samples

curl -X GET https://api-sandbox.split.cash/contacts/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/contacts/{id}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/contacts/{id}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/contacts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts/{id}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /contacts/{id}

Get a single Contact by its ID

Parameters

Parameter	In	Type	Required	Description
id	path	string(UUID)	true	Contact ID (`Contact.data.id`)

Example responses

{
  "data": {
    "id": "fcabeacb-2ef6-4b27-ba19-4f6fa0d57dcb",
    "name": "Outstanding Tours Pty Ltd",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetAContactResponse
404	Not Found	Not Found	None

Remove a Contact

Code samples

curl -X DELETE https://api-sandbox.split.cash/contacts/{id} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/contacts/{id}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/contacts/{id}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/contacts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts/{id}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /contacts/{id}

Parameters

Parameter	In	Type	Required	Description
id	path	string(UUID)	true	Contact ID (`Contact.data.id`)

Responses

Status	Meaning	Description	Schema
204	No Content	No description	None

Update a Contact

Code samples

curl -X PATCH https://api-sandbox.split.cash/contacts/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "name": "My very own alias"
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "name": "My very own alias"
}'

result = RestClient.patch 'https://api-sandbox.split.cash/contacts/{id}', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.patch('https://api-sandbox.split.cash/contacts/{id}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api-sandbox.split.cash/contacts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "name": "My very own alias"
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/contacts/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /contacts/{id}

You can update the name of any Contact. This is essentially an alias you can use to provide something contextually meaninful.

Body parameter

{
  "name": "My very own alias"
}

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	Contact ID (`Contact.data.id`)
body	body	UpdateAContactRequest	true	No description
» name	body	string	true	The name of the Contact

Example responses

{
  "data": {
    "id": "fcabeacb-2ef6-4b27-ba19-4f6fa0d57dcb",
    "name": "My very own alias",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	UpdateAContactResponse
404	Not Found	Not Found	None

Open Agreements

An Open Agreement is essentially an Agreement template with no specific authoriser. Each time an Open Agreement is accepted by either a Split account holder or anyone, the authoriser is added to your Contacts list and a new Agreement is automatically created between the Open Agreement initiator and the authoriser.

An Open Agreement can be accepted multiple times by different parties and the result is the same: A new Agreement. Additionally, an Open Agreement can be accepted by anybody, not just other Split users. This is achieved by using our Instant Account Verification process as part of accepting an Open Agreement.

Lifecycle

An Open Agreement can have the following statuses:

Status	Description
`active`	The Open Agreement can be viewed and accepted.
`closed`	The Open Agreement can not be viewed or accepted.

Create an Open Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/open_agreements \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "title": "Subscription Plan A",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "title": "Subscription Plan A",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/open_agreements', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/open_agreements', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/open_agreements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "title": "Subscription Plan A",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/open_agreements',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /open_agreements

Create an Open Agreement that can be accepted by anyone.

You can set any of the term metrics to null if you wish them to not have a limit.

Body parameter

{
  "title": "Subscription Plan A",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	CreateOpenAgreementRequest	true	No description
» title	body	string	true	Title of the Open Agreement (Visible to authorisers)
» terms	body	Terms	true	Terms
»» per_payout	body	PerPayout	true	No description
»»» min_amount	body	number	false	Minimum amount in cents a PR can be in order to be auto-approved
»»» max_amount	body	number	false	Maximum amount in cents a PR can be in order to be auto-approved
»» per_frequency	body	PerFrequency	true	No description
»»» days	body	number	false	Amount of days to apply against the frequency
»»» max_amount	body	number	false	Maximum amount in cents the total of all PRs can be for the duration of the frequency

Example responses

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "active",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "min_amount": null,
        "max_amount": 10000
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/aecff76d-13e0-4e17-b7c5-844ae07fa675/agreements/invitation"
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	CreateOpenAgreementResponse

List all Open Agreements

Code samples

curl -X GET https://api-sandbox.split.cash/open_agreements \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/open_agreements', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/open_agreements', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/open_agreements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/open_agreements',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /open_agreements

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "OA.1",
      "title": "Subscription Plan A",
      "status": "active",
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      },
      "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
    },
    {
      "ref": "OA.2",
      "title": "Subscription Plan B",
      "status": "closed",
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": null,
          "max_amount": null
        }
      },
      "link": "https://go-sandbox.split.cash/open_agreements/948e3662-154d-42d1-bdc9-a05c251d3981/agreements/invitation"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListAllOpenAgreementsResponse

Activate a closed Open Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/activate \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/activate', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/activate', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/activate", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/activate',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /open_agreements/{open_agreement_ref}/activate

Allow the Open Agreement to viewed and accepted

Parameters

Parameter	In	Type	Required	Description
open_agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "active",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ActivateOpenAgreementResponse

Close an active Open Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/close \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/close', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/close', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/close", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/open_agreements/{open_agreement_ref}/close',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /open_agreements/{open_agreement_ref}/close

Disable the Open Agreement from being viewed or accepted

Parameters

Parameter	In	Type	Required	Description
open_agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "closed",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	CloseOpenAgreementResponse

Payments

A Payment is made up of two parts:

General details about the Payment.
One or many Payouts with individual recipients, amounts and descriptions.

Lifecycle

The Payment is simply a group of Payouts therefore it does not have a particular status. Its Payouts however have their status regularly updated, for a list of possible Payout statuses check out the Transactions.

Make a Payment

Code samples

curl -X POST https://api-sandbox.split.cash/payments \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "description": "The SuperPackage",
  "matures_at": "2016-09-13T00:00:00Z",
  "payouts": [
    {
      "amount": 30000,
      "description": "A tandem skydive jump SB23094",
      "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
      "metadata": {
        "invoice_ref": "BILL-0001",
        "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    },
    {
      "amount": 30000,
      "description": "A scuba dive SDS5464",
      "recipient_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
    }
  ],
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "description": "The SuperPackage",
  "matures_at": "2016-09-13T00:00:00Z",
  "payouts": [
    {
      "amount": 30000,
      "description": "A tandem skydive jump SB23094",
      "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
      "metadata": {
        "invoice_ref": "BILL-0001",
        "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    },
    {
      "amount": 30000,
      "description": "A scuba dive SDS5464",
      "recipient_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
    }
  ],
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/payments', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payments', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "description": "The SuperPackage",
  "matures_at": "2016-09-13T00:00:00Z",
  "payouts": [
    {
      "amount": 30000,
      "description": "A tandem skydive jump SB23094",
      "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
      "metadata": {
        "invoice_ref": "BILL-0001",
        "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    },
    {
      "amount": 30000,
      "description": "A scuba dive SDS5464",
      "recipient_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
    }
  ],
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payments',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payments

Body parameter

{
  "description": "The SuperPackage",
  "matures_at": "2016-09-13T00:00:00Z",
  "payouts": [
    {
      "amount": 30000,
      "description": "A tandem skydive jump SB23094",
      "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
      "metadata": {
        "invoice_ref": "BILL-0001",
        "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    },
    {
      "amount": 30000,
      "description": "A scuba dive SDS5464",
      "recipient_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
    }
  ],
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	MakeAPaymentRequest	true	No description
» description	body	string	true	User description. Only visible to the payer
» matures_at	body	string	true	Date & time in UTC ISO8601 the Payment should be processed
» payouts	body	[Payout]	true	One or many Payouts
»» Payout	body	Payout	false	The actual Payout
»»» amount	body	number	true	Amount in cents to pay the recipient
»»» description	body	string	true	Description that both the payer an recipient can see
»»» recipient_id	body	string	true	Contact bank account to pay (`Contact.data.bank_account.id`)
»»» metadata	body	Metadata	false	Use for your custom data an certain Split customisations
»» metadata	body	Metadata	false	Use for your custom data an certain Split customisations

Example responses

{
  "data": {
    "ref": "PB.1",
    "payouts": [
      {
        "ref": "D.1",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A tandem skydive jump SB23094",
        "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
        "to_id": "48b89364-1577-4c81-ba02-96705895d457",
        "metadata": {
          "invoice_ref": "BILL-0001",
          "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
          "custom_key": "Custom string",
          "another_custom_key": "Maybe a URL"
        }
      },
      {
        "ref": "D.2",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A scuba dive SDS5464",
        "from_id": "48b89364-1577-4c81-ba02-96705895d457",
        "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
      }
    ],
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	MakeAPaymentResponse

List all Payments

Code samples

curl -X GET https://api-sandbox.split.cash/payments \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payments', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payments', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payments',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payments

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "PB.1",
      "payouts": [
        {
          "ref": "D.1",
          "batch_description": "This description is only available to the payer",
          "matures_at": "2016-09-13T23:50:44Z",
          "created_at": "2016-09-10T23:50:44Z",
          "status": "maturing",
          "amount": 30000,
          "description": "The recipient will see this description",
          "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
          "to_id": "48b89364-1577-4c81-ba02-96705895d457",
          "metadata": {
            "invoice_ref": "BILL-0001",
            "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
            "custom_key": "Custom string",
            "another_custom_key": "Maybe a URL"
          }
        },
        {
          "ref": "D.2",
          "batch_description": "This description is only available to the payer",
          "matures_at": "2016-09-13T23:50:44Z",
          "created_at": "2016-09-10T23:50:44Z",
          "status": "maturing",
          "amount": 30000,
          "description": "The recipient will see this description",
          "from_id": "48b89364-1577-4c81-ba02-96705895d457",
          "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
        }
      ],
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListAllPaymentsResponse

Get a Payment

Code samples

curl -X GET https://api-sandbox.split.cash/payments/{payment_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payments/{payment_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payments/{payment_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payments/{payment_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payments/{payment_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payments/{payment_ref}

Get a single payment by its reference

Parameters

Parameter	In	Type	Required	Description
payment_ref	path	string	true	Payment reference

Example responses

{
  "data": {
    "ref": "PB.1",
    "payouts": [
      {
        "ref": "D.1",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44",
        "status": "maturing",
        "amount": 30000,
        "description": "A tandem skydive jump SB23094",
        "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
        "to_id": "48b89364-1577-4c81-ba02-96705895d457",
        "metadata": {
          "invoice_ref": "BILL-0001",
          "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
          "custom_key": "Custom string",
          "another_custom_key": "Maybe a URL"
        }
      },
      {
        "ref": "D.2",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A scuba dive SDS5464",
        "from_id": "48b89364-1577-4c81-ba02-96705895d457",
        "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
      }
    ],
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetAPaymentResponse

Payouts

Payouts are what a compose a Payment. One or all Payouts can be voided individually as part of the larger Payment.

Void a Payout

Code samples

curl -X DELETE https://api-sandbox.split.cash/payouts/{debit_ref} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/payouts/{debit_ref}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/payouts/{debit_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/payouts/{debit_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payouts/{debit_ref}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /payouts/{debit_ref}

You can void any Payout debit from your account that has not yet matured. In the case where it has matured, you can send a Refund Request to the Payout recipient once the Payout has successfully cleared in order to reverse the transaction.

Parameters

Parameter	In	Type	Required	Description
debit_ref	path	string	true	Payout debit reference

Responses

Status	Meaning	Description	Schema
204	No Content	No Content	None

Payment Requests

A Payment Request (PR) is used to request payment from another party. Additionally, a Payment Request can be approved by anybody, not just other Split users. This is achieved by using our Instant Account Verification process as part of approving a Payment Request.

Applicable scenarios

A Split account sends a PR to a Contact that is a Split account:
1. The authoriser must either approve or decline the request; or
2. Given there is an Agreement in place and the PR is within the terms of the Agreement, then the PR will be automatically approved; or
3. Given the PR is not within the terms of the Agreement, then the authoriser must either approve or decline the request.
A Split accounts sends a PR to a Contact that is not a Split account:
1. Given there is an Agreement in place and the PR is within the terms of the Agreement, then the PR will be automatically approved; or
2. Given the PR is not within the terms of the Agreement, then the PR will not be created; or
3. There is no Agreement in place, then the PR will not be created.

Direction

Payment Requests are broken up by direction:

Incoming: An incoming Payment Request (you are the authoriser/payer)
Outgoing: An outgoing Payment Request (you are the initiator/payee)

There are two response fields that differ depending on the direction:

Field	Description
`debit_ref`	Only visible to the PR authoriser (incoming PRs). This reference corresponds to the newly created debit to process the approved PR.
`credit_ref`	Only visible to the PR initiator (outgoing PRs). This reference corresponds to the newly created credit from the approved PR.

Lifecycle

A Payment Request can have the following statuses:

Status	Description
`pending_approval`	Waiting for the authoriser to approve the PR.
`approved`	The authoriser has approved the PR.
`declined`	The payer has declined the PR.
`cancelled`	The initiator has cancelled the PR.

Request Payment

Code samples

curl -X POST https://api-sandbox.split.cash/payment_requests \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "description": "Visible to both initiator and authoriser",
  "matures_at": "12/19/2016 2:10:56 AM",
  "amount": 99000,
  "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "description": "Visible to both initiator and authoriser",
  "matures_at": "12/19/2016 2:10:56 AM",
  "amount": 99000,
  "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/payment_requests', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payment_requests', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payment_requests", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "description": "Visible to both initiator and authoriser",
  "matures_at": "12/19/2016 2:10:56 AM",
  "amount": 99000,
  "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payment_requests

Body parameter

{
  "description": "Visible to both initiator and authoriser",
  "matures_at": "12/19/2016 2:10:56 AM",
  "amount": 99000,
  "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	MakeAPaymentRequestRequest	true	No description
» description	body	string	true	Description visible to the initiator (payee) & authoriser (payer)
» matures_at	body	string	true	Date & time in UTC ISO8601 that the Payment will be processed if the request is approved
» amount	body	number	true	Amount in cents to pay the initiator
» authoriser_id	body	string	true	The Contact bank account that will be used to pay the PR (`Contact.data.bank_account.id`)'
» metadata	body	Metadata	false	Use for your custom data an certain Split customisations

Example responses

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T02:10:56Z",
    "credit_ref": null,
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	MakeAPaymentRequestResponse

Approve a Payment Request

Code samples

curl -X POST https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/approve \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/approve', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/approve', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/approve", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/approve',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payment_requests/{payment_request_ref}/approve

Parameters

Parameter	In	Type	Required	Description
payment_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "debit_ref": "D.b",
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ApprovePaymentRequestResponse

Decline a Payment Request

Code samples

curl -X POST https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/decline \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/decline', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/decline', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/decline", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/decline',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payment_requests/{payment_request_ref}/decline

Parameters

Parameter	In	Type	Required	Description
payment_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "declined",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "debit_ref": null,
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	No description	DeclinePaymentRequestResponse

Get a Payment Request

Code samples

curl -X GET https://api-sandbox.split.cash/payment_requests/{payment_request_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payment_requests/{payment_request_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payment_requests/{payment_request_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payment_requests/{payment_request_ref}

Parameters

Parameter	In	Type	Required	Description
payment_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "credit_ref": "C.b",
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetAPaymentRequestResponse

Cancel a Payment Request

Code samples

curl -X DELETE https://api-sandbox.split.cash/payment_requests/{payment_request_ref} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/payment_requests/{payment_request_ref}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/payment_requests/{payment_request_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /payment_requests/{payment_request_ref}

A PR can only be cancelled if it has not yet matured.

Parameters

Parameter	In	Type	Required	Description
payment_request_ref	path	string	true	Single value, exact match

Responses

Status	Meaning	Description	Schema
204	No Content	No Content	None

List incoming Payment Requests

Code samples

curl -X GET https://api-sandbox.split.cash/payment_requests/incoming \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payment_requests/incoming', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payment_requests/incoming', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payment_requests/incoming", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/incoming',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payment_requests/incoming

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "PR.2",
      "initiator_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "authoriser_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "status": "approved",
      "responded_at": "2016-12-19T02:10:18Z",
      "created_at": "2016-12-19T02:09:09Z",
      "debit_ref": "D.a",
      "payout": {
        "amount": 30000,
        "description": "The SuperPackage",
        "matures_at": "2016-12-20T00:00:00Z"
      }
    },
    {
      "ref": "PR.3",
      "initiator_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "authoriser_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T02:10:56Z",
      "debit_ref": null,
      "payout": {
        "amount": 99000,
        "description": "The elite package for 4",
        "matures_at": "2016-12-25T00:00:00Z"
      },
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListIncomingPaymentRequestsResponse

List outgoing Payment Requests

Code samples

curl -X GET https://api-sandbox.split.cash/payment_requests/outgoing \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payment_requests/outgoing', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payment_requests/outgoing', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payment_requests/outgoing", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/outgoing',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payment_requests/outgoing

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "PR.4",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "approved",
      "responded_at": "2016-12-19T02:10:18Z",
      "created_at": "2016-12-19T02:09:09Z",
      "credit_ref": "C.a",
      "payout": {
        "amount": 30000,
        "description": "The SuperPackage",
        "matures_at": "2016-12-20T00:00:00Z"
      }
    },
    {
      "ref": "PR.5",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T02:10:56Z",
      "credit_ref": null,
      "payout": {
        "amount": 99000,
        "description": "The elite package for 4",
        "matures_at": "2016-12-25T00:00:00Z"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListOutgoingPaymentRequestsResponse

Get a Payment Request's history

Code samples

curl -X GET https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/history \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/history', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/history', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/history", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payment_requests/{payment_request_ref}/history',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payment_requests/{payment_request_ref}/history

Gives you visibility of the entire Payment Request lifecycle including the generated debit and credit transactions.

Parameters

Parameter	In	Type	Required	Description
payment_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": [
    {
      "type": "payout_request",
      "event": "requested",
      "at": "2017-01-05T07:47:45Z",
      "ref": "PR.3",
      "by": "Fancy Pants (fancy_pants)"
    },
    {
      "type": "payout_request",
      "event": "approved",
      "at": "2017-01-07T06:13:52Z",
      "ref": "PR.3",
      "by": "Lycra Co (lycra_co)"
    },
    {
      "type": "debit",
      "event": "scheduled",
      "at": "2017-01-07T06:13:52Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "scheduled",
      "at": "2017-01-07T06:13:52Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "matured",
      "at": "2017-01-08T04:30:14Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "processing",
      "at": "2017-01-08T04:30:14Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "clearing",
      "at": "2017-01-08T19:02:20Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "cleared",
      "at": "2017-01-11T19:07:52Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "matured",
      "at": "2017-01-11T19:07:52Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "processing",
      "at": "2017-01-12T04:30:25Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "clearing",
      "at": "2017-01-12T05:17:32Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "cleared",
      "at": "2017-01-15T05:27:12Z",
      "ref": "C.e",
      "by": "Split Payments"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetAPaymentRequestsHistoryResponse

Refunds

Refunds can be issued for any successfully cleared Payout (credit) transactions.

Direction

Refunds are broken up by direction:

Incoming: An incoming Refund (you are the recipient of the refund)
Outgoing: An outgoing Refund (you are the issuer of the refund)

There are two response fields that differ depending on the direction:

Field	Description
`debit_ref`	Only visible to the Refund issuer (outgoing Refunds). This reference corresponds to the newly created debit to process the Refund.
`credit_ref`	Only visible to the Refund recipient (incoming Refunds). This reference corresponds to the newly created credit to process the Refund.

Issue a Refund

Code samples

curl -X POST https://api-sandbox.split.cash/credits/{credit_ref}/refunds \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/credits/{credit_ref}/refunds', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/credits/{credit_ref}/refunds', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/credits/{credit_ref}/refunds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/credits/{credit_ref}/refunds',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /credits/{credit_ref}/refunds

Certain rules apply to the issuance of a refund:

Must be applied against a successfully cleared payout (credit)
The refund amount may not exceed the original amount of the credit

Body parameter

{
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Parameters

Parameter	In	Type	Required	Description
credit_ref	path	string	true	No description
body	body	IssueARefundRequest	true	No description
» amount	body	number	true	Amount in cents refund
» reason	body	string	false	Reason for the refund. Visible to both parties.
» metadata	body	Metadata	false	Use for your custom data an certain Split customisations

Example responses

{
  "data": {
    "ref": "PRF.1",
    "for_ref": "C.59",
    "debit_ref": "D.hi",
    "created_at": "2017-05-08T07:20:24Z",
    "amount": 500,
    "reason": "Because reason",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	IssueARefundResponse

List incoming Refunds

Code samples

curl -X GET https://api-sandbox.split.cash/refunds/incoming \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/refunds/incoming', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/refunds/incoming', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/refunds/incoming", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/refunds/incoming',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /refunds/incoming

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "PRF.2",
      "for_ref": "D.5",
      "credit_ref": "C.q",
      "created_at": "2017-05-09T04:45:26Z",
      "amount": 5,
      "reason": "Because reason",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListIncomingRefundsResponse

List outgoing Refunds

Code samples

curl -X GET https://api-sandbox.split.cash/refunds/outgoing \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/refunds/outgoing', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/refunds/outgoing', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/refunds/outgoing", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/refunds/outgoing',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /refunds/outgoing

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "PRF.2",
      "for_ref": "C.5",
      "debit_ref": "D.5a",
      "created_at": "2017-05-09T04:45:26Z",
      "amount": 5,
      "reason": "Because reason",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListOutgoingRefundsResponse

Retrieve a Refund

Code samples

curl -X GET https://api-sandbox.split.cash/refunds/{refund_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/refunds/{refund_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/refunds/{refund_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/refunds/{refund_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/refunds/{refund_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /refunds/{refund_ref}

Get a single Refund by its reference

Parameters

Parameter	In	Type	Required	Description
refund_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "PRF.1",
    "for_ref": "C.59",
    "debit_ref": "D.hi",
    "created_at": "2017-05-08T07:20:24Z",
    "amount": 500,
    "reason": "Because reason",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	RetrieveARefundResponse

Refund Requests

Manage Refund Requests (RR) applied against successfully cleared Payouts. A refunder corresponds to a recipient of a successfully cleared Payout (credit).

Direction

Refund Requests are broken up by direction:

Incoming: An incoming Refund Request (you are the authoriser/refunder)
Outgoing: An outgoing Refund Request (you are the initiator/refundee)

There are two response fields that differ depending on the direction:

Field	Description
`debit_ref`	Only visible to the RR authoriser (incoming RRs). This reference corresponds to the newly created debit to process the approved RR.
`credit_ref`	Only visible to the RR initiator (outgoing RRs). This reference corresponds to the newly created credit from the approved RR.

Lifecycle

A Refund Request can have the following statuses:

Status	Description
`pending_approval`	Waiting for the authoriser to approve the RR.
`approved`	The authoriser has approved the RR.
`declined`	The payer has declined the RR.
`cancelled`	The initiator has cancelled the RR.

Request a Refund

Code samples

curl -X POST https://api-sandbox.split.cash/payout_refund_requests \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "for_ref": "D.1",
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "for_ref": "D.1",
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/payout_refund_requests', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payout_refund_requests', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payout_refund_requests", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "for_ref": "D.1",
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payout_refund_requests

Certain rules apply to the creation of a Refund Request:

Must be applied against a successfully cleared payout (debit)
The refund amount requested from a Payout recipient may not exceed the original amount of the Payout

Body parameter

{
  "for_ref": "D.1",
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	RequestARefundRequest	true	No description
» for_ref	body	string	true	The Payout debit reference to refund against
» amount	body	number	true	Amount in cents to request from the original payout recipient
» reason	body	string	false	Reason for the refund request. Visible to both parties.
» metadata	body	Metadata	false	Use for your custom data an certain Split customisations

Example responses

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "credit_ref": null,
    "amount": 500,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	RequestARefundResponse

Approve Refund Request

Code samples

curl -X POST https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/approve \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/approve', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/approve', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/approve", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/approve',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payout_refund_requests/{payout_refund_request_ref}/approve

Parameters

Parameter	In	Type	Required	Description
payout_refund_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T04:42:59Z",
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "C.1",
    "debit_ref": "D.2c3",
    "amount": 100,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ApprovePayoutRefundRequestResponse

Decline Refund Request

Code samples

curl -X POST https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/decline \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.post 'https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/decline', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/decline', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/decline", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}/decline',
{
  method: 'POST',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /payout_refund_requests/{payout_refund_request_ref}/decline

Parameters

Parameter	In	Type	Required	Description
payout_refund_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "declined",
    "responded_at": "2016-12-19T04:42:59Z",
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "debit_ref": null,
    "amount": 100,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	DeclinePayoutRefundRequestResponse

Retrieve a Refund Request

Code samples

curl -X GET https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payout_refund_requests/{payout_refund_request_ref}

Get a specific Refund Request by its reference

Parameters

Parameter	In	Type	Required	Description
payout_refund_request_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "credit_ref": null,
    "amount": 10000,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	RetrieveARefundRequestResponse

Cancel a Refund Request

Code samples

curl -X DELETE https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/{payout_refund_request_ref}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /payout_refund_requests/{payout_refund_request_ref}

A Refund Request can only be canceled if it is pending approval.

Parameters

Parameter	In	Type	Required	Description
payout_refund_request_ref	path	string	true	Single value, exact match

Responses

Status	Meaning	Description	Schema
204	No Content	No Content	None

List incoming Refund Requests

Code samples

curl -X GET https://api-sandbox.split.cash/payout_refund_requests/incoming \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payout_refund_requests/incoming', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payout_refund_requests/incoming', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payout_refund_requests/incoming", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/incoming',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payout_refund_requests/incoming

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "RR.2",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "approved",
      "responded_at": "2016-12-19T04:42:59Z",
      "created_at": "2016-12-19T04:34:38Z",
      "for_ref": "C.1",
      "debit_ref": "D.2c3",
      "amount": 100,
      "reason": "Because reasons",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListIncomingRefundRequestsResponse

List outgoing Refund Requests

Code samples

curl -X GET https://api-sandbox.split.cash/payout_refund_requests/outgoing \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/payout_refund_requests/outgoing', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/payout_refund_requests/outgoing', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/payout_refund_requests/outgoing", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/payout_refund_requests/outgoing',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /payout_refund_requests/outgoing

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "RR.2",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T04:34:38Z",
      "for_ref": "D.1",
      "credit_ref": null,
      "amount": 10000,
      "reason": "Because reasons",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListOutgoingRefundRequestsResponse

Transactions

The transactions endpoint provides a detailed look at all past, current and future scheduled debits & credits relating to the Split account. In other words, we not only show the transactions initiated by the Split account but also show transactions where the Split account is on the receiving end - even for payments that have not yet matured.

Lifecycle

A transaction (debit or credit) can have the following statuses:

Status	Description
`maturing`	The maturation date has not yet been reached
`matured`	The maturation date has been reached and the transaction is eligible for processing.
`processing`	The transaction has been submitted to the bank.
`clearing`	Waiting for confirmation from the bank that the transaction has succeeded.
`cleared`	The transaction is complete.
`rejected`	The bank has rejected the transaction due to incorrect bank account details.
`returned`	The transaction did not successfully clear.
`voided`	The transaction has been cancelled and is no longer eligible for processing.
`pending_verification`	The bank account must be verified before the transaction can proceed.
`paused`	The transaction has temporary been paused by Split pending internal review.
`prefailed`	The transaction was never submitted to the bank because we detected that there were insufficient funds. The transaction can be retried.

Failure reasons

Example response

{
  "data": [
    {
      "ref": "D.3",
      "parent_ref": null,
      "type": "debit",
      "category": "payout_refund",
      "created_at": "2016-12-07T23:15:00Z",
      "matures_at": "2016-12-10T23:15:00Z",
      "cleared_at": null,
      "bank_ref": null,
      "status": "returned",
      "failure_reason": "refer_to_customer"
      "party_name": "Sanford-Rees",
      "party_nickname": "sanford-rees-8",
      "description": null,
      "amount": 1
    }
  ]
}

The rejected, returned, voided & prefailed statuses are always accompanied by a failure_reason:

Reason	Description
`invalid_bsb_number`	BSB number is invalid
`payment_stopped`	The payment was stopped at the bank. Can be due to a customer requesting a stop payment with their financial institution.
`account_closed`	The bank account is closed
`customer_deceased`	Customer is deceased
`incorrect_account_number`	Account number is incorrect
`refer_to_customer`	Usually due to insufficient funds
`refer_to_split`	Failed due to reasons not listed here. Please contact us.
`insufficient_funds`	Insufficient funds

List all transactions

Code samples

curl -X GET https://api-sandbox.split.cash/transactions \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/transactions', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/transactions', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/transactions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/transactions',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /transactions

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match
ref	query	string	false	Single value, exact match
parent_ref	query	string	false	Single value, exact match
bank_ref	query	string	false	Single value, exact match
status	query	array[string]	false	Multiple values, exact match
category	query	array[string]	false	Multiple values, exact match
type	query	array[string]	false	Multiple values, exact match
other_party	query	string	false	Single value, string search
other_party_bank_ref	query	string	false	Single value, exact match
description	query	string	false	Single value, string search
min_amount	query	integer	false	Cents, Single value, exact match
max_amount	query	integer	false	Cents, single value, exact match
min_created_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, Single value, exact match
max_created_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, single value, exact match
min_matured_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, Single value, exact match
max_matured_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, single value, exact match
min_cleared_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, Single value, exact match
max_cleared_date	query	string(date-time)	false	Date/time UTC ISO 8601 format, single value, exact match

Enumerated Values

Parameter	Value
status	maturing
status	matured
status	processing
status	clearing
status	cleared
status	rejected
status	returned
status	voided
status	pending_verification
status	paused
category	payout
category	payout_refund
category	invoice
type	debit
type	credit

Example responses

{
  "data": [
    {
      "ref": "D.3",
      "parent_ref": null,
      "type": "debit",
      "category": "payout_refund",
      "created_at": "2016-12-07T23:15:00Z",
      "matures_at": "2016-12-10T23:15:00Z",
      "cleared_at": "2016-12-10T23:15:00Z",
      "bank_ref": "DT.9a",
      "status": "Cleared",
      "party_name": "Sanford-Rees",
      "party_nickname": null,
      "party_bank_ref": "CT.11",
      "description": null,
      "amount": 1
    },
    {
      "ref": "D.2",
      "parent_ref": "PB.2",
      "type": "debit",
      "category": "payout",
      "created_at": "2016-12-06T23:15:00Z",
      "matures_at": "2016-12-09T23:15:00Z",
      "cleared_at": null,
      "bank_ref": null,
      "status": " Pending",
      "party_name": "Gutmann-Schmidt",
      "party_nickname": null,
      "party_bank_ref": null,
      "description": "Batteries for hire",
      "amount": 1
    },
    {
      "ref": "C.2",
      "parent_ref": null,
      "type": "credit",
      "category": "payout",
      "created_at": "2016-12-05T23:15:00Z",
      "matures_at": "2016-12-06T23:15:00Z",
      "cleared_at": "2016-12-09T23:15:00Z",
      "bank_ref": "CT.1",
      "status": "Pending",
      "party_name": "Price and Sons",
      "party_nickname": "price-and-sons-2",
      "party_bank_ref": null,
      "description": "Money for jam",
      "amount": 1
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListAllTransactionsResponse

Unassigned Agreements

An agreement with no preset authoriser that can only be accepted once and must be accepted within a predefined time period.

Unassigned Agreements are shared using the generated link available in the response body. You can then include it in an email, text message, embed it in an iFrame, etc...

Propose an Unassigned Agreement

Code samples

curl -X POST https://api-sandbox.split.cash/unassigned_agreements \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}' \
  -d '{
  "expiry_in_seconds": 60,
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

require 'rest-client'
require 'json'

headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

params = '{
  "expiry_in_seconds": 60,
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}'

result = RestClient.post 'https://api-sandbox.split.cash/unassigned_agreements', params, headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.post('https://api-sandbox.split.cash/unassigned_agreements', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-sandbox.split.cash/unassigned_agreements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');
const inputBody = '{
  "expiry_in_seconds": 60,
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}';
const headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/unassigned_agreements',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /unassigned_agreements

Create an Unassigned Agreement

You can set any of the term metrics to null if you wish them to not have a limit.

Body parameter

{
  "expiry_in_seconds": 60,
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	ProposeUnassignedAgreementRequest	true	No description
» expiry_in_seconds	body	number	true	The amount of time in seconds before the Unassigned Agreement can no longer be accepted.
» terms	body	Terms	true	Terms
»» per_payout	body	PerPayout	true	No description
»»» min_amount	body	number	false	Minimum amount in cents a PR can be in order to be auto-approved
»»» max_amount	body	number	false	Maximum amount in cents a PR can be in order to be auto-approved
»» per_frequency	body	PerFrequency	true	No description
»»» days	body	number	false	Amount of days to apply against the frequency
»»» max_amount	body	number	false	Maximum amount in cents the total of all PRs can be for the duration of the frequency

Example responses

{
  "data": {
    "ref": "A.4k",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "assignment_expires_at": "2017-03-20T00:54:27Z",
    "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
  }
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	ProposeUnassignedAgreementResponse

List all Unassigned Agreements

Code samples

curl -X GET https://api-sandbox.split.cash/unassigned_agreements \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/unassigned_agreements', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/unassigned_agreements', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/unassigned_agreements", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/unassigned_agreements',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /unassigned_agreements

Will return all Unassigned Agreements that have not yet be accepted.

Parameters

Parameter	In	Type	Required	Description
page	query	string	false	Page of results to return, single value, exact match
per_page	query	string	false	Number of results per page, single value, exact match

Example responses

{
  "data": [
    {
      "ref": "A.4k",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      },
      "assignment_expires_at": "2017-03-20T00:54:27Z",
      "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
    },
    {
      "ref": "A.7ea",
      "initiator_id": "b61fc159-8779-4a17-a826-e398e3e7e211",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-21T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": null,
          "min_amount": null
        },
        "per_frequency": {
          "days": null,
          "max_amount": null
        }
      },
      "assignment_expires_at": "2017-03-21T00:54:27Z",
      "link": "https://go-sandbox.split.cash/unassigned_agreements/4e2728cc-b4ba-42c2-a6c3-26a7758de58d/invitation"
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	ListUnassignedAgreementsResponse

Get an Unassigned Agreement

Code samples

curl -X GET https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref} \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /unassigned_agreements/{unassigned_agreement_ref}

Get a single Unassigned Agreement by its reference

Parameters

Parameter	In	Type	Required	Description
unassigned_agreement_ref	path	string	true	Single value, exact match

Example responses

{
  "data": {
    "ref": "A.4k",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "assignment_expires_at": "2017-03-20T00:54:27Z",
    "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetUnassignedAgreementResponse

Delete an Unassigned Agreement

Code samples

curl -X DELETE https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref} \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Authorization': 'bearer {access-token}'
}

result = RestClient.delete 'https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}', headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'bearer {access-token}'
}

r = requests.delete('https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/unassigned_agreements/{unassigned_agreement_ref}',
{
  method: 'DELETE',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

DELETE /unassigned_agreements/{unassigned_agreement_ref}

An Unassigned Agreement can be deleted at anytime as long as it has not yet been assigned an authoriser.

Parameters

Parameter	In	Type	Required	Description
unassigned_agreement_ref	path	string	true	Single value, exact match

Responses

Status	Meaning	Description	Schema
204	No Content	No Content	None

Users

All about the currently authenticated user.

Get user details

Code samples

curl -X GET https://api-sandbox.split.cash/user \
  -H 'Accept: application/json' \
  -H 'Authorization: bearer {access-token}'

require 'rest-client'
require 'json'

headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

result = RestClient.get 'https://api-sandbox.split.cash/user', {}, headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
}

r = requests.get('https://api-sandbox.split.cash/user', params={

}, headers = headers)

print r.json()

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-sandbox.split.cash/user", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

const request = require('node-fetch');

const headers = {
  'Accept': 'application/json',
  'Authorization': 'bearer {access-token}'
};

fetch('https://api-sandbox.split.cash/user',
{
  method: 'GET',
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

GET /user

Example responses

{
  "data": {
    "first_name": "Bear",
    "last_name": "Dog",
    "mobile_phone": "0456945832",
    "email": "[email protected]",
    "account": {
      "name": "Dog Bones Inc",
      "nickname": "dog-bones-inc",
      "abn": "129959040",
      "phone": "0418495033",
      "street_address": "98 Acme Avenue",
      "suburb": "Lead",
      "state": "NSW",
      "postcode": "2478"
    }
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	GetUserDetailsResponse

Schemas

ProposeAgreementRequest

{
  "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Properties

Propose an Agreement (request)

Name	Type	Required	Description
authoriser_id	string	true	The Contact's account ID (`Contact.data.account.id`)
terms	Terms	true	No description

Terms

{
  "per_payout": {
    "min_amount": 0,
    "max_amount": 10000
  },
  "per_frequency": {
    "days": 7,
    "max_amount": 1000000
  }
}

Properties

Terms

Name	Type	Required	Description
per_payout	PerPayout	true	No description
per_frequency	PerFrequency	true	No description

PerPayout

{
  "min_amount": 0,
  "max_amount": 10000
}

Properties

Per payout terms

Name	Type	Required	Description
min_amount	number	false	Minimum amount in cents a PR can be in order to be auto-approved
max_amount	number	false	Maximum amount in cents a PR can be in order to be auto-approved

PerFrequency

{
  "days": 7,
  "max_amount": 1000000
}

Properties

Per frequency terms

Name	Type	Required	Description
days	number	false	Amount of days to apply against the frequency
max_amount	number	false	Maximum amount in cents the total of all PRs can be for the duration of the frequency

ProposeAgreementResponse

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Properties

Propose an Agreement (response)

Name	Type	Required	Description
data	object	true	No description

ApproveAgreementResponse

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "accepted",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Properties

Approve an Agreement (response)

Name	Type	Required	Description
data	object	true	No description

DeclineAgreementResponse

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "declined",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Properties

Decline an Agreement (response)

Name	Type	Required	Description
data	object	true	No description

GetAgreementResponse

{
  "data": {
    "ref": "A.2",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
    "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
    "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
    "status": "approved",
    "responded_at": "2017-03-20T02:13:11Z",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": 1
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    }
  }
}

Properties

Get an Agreement (response)

Name	Type	Required	Description
data	object	true	No description

ListIncomingAgreementsResponse

{
  "data": [
    {
      "ref": "A.2",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
      "contact_id": "0d290763-bd5a-4b4d-a8ce-06c64c4a697b",
      "bank_account_id": "fb9381ec-22af-47fd-8998-804f947aaca3",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": 1
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      }
    },
    {
      "ref": "A.1",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "56df206a-aaff-471a-b075-11882bc8906a",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-16T22:51:48Z",
      "terms": {
        "per_payout": {
          "max_amount": 5000,
          "min_amount": 0
        },
        "per_frequency": {
          "days": "1",
          "max_amount": 10000
        }
      }
    }
  ]
}

Properties

List incoming Agreements (response)

Name	Type	Required	Description
data	[object]	true	No description

ListOutgoingAgreementsResponse

{
  "data": [
    {
      "ref": "A.4",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "8df89c16-330f-462b-8891-808d7bdceb7f",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": 1
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      }
    },
    {
      "ref": "A.3",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "authoriser_id": "56df206a-aaff-471a-b075-11882bc8906a",
      "contact_id": "a80ac411-c8fb-45c0-9557-607c54649907",
      "bank_account_id": "fa80ac411-c8fb-45c0-9557-607c54649907",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-16T22:51:48Z",
      "terms": {
        "per_payout": {
          "max_amount": 5000,
          "min_amount": 0
        },
        "per_frequency": {
          "days": "1",
          "max_amount": 10000
        }
      }
    }
  ]
}

Properties

List outgoing Agreements (response)

Name	Type	Required	Description
data	[object]	true	No description

ListAllBankAccountsResponse

{
  "data": [
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "branch_code": "493192",
      "bank_name": "National Australia Bank",
      "account_number": "3993013",
      "status": "active"
    },
    {
      "id": "56df206a-aaff-471a-b075-11882bc8906a",
      "branch_code": "302193",
      "bank_name": "National Australia Bank",
      "account_number": "119302",
      "status": "removed"
    }
  ]
}

Properties

List all Bank Accounts (response)

Name	Type	Required	Description
data	[object]	true	No description

CreateOpenAgreementRequest

{
  "title": "Subscription Plan A",
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Properties

Create an Open Agreement (request)

Name	Type	Required	Description
title	string	true	Title of the Open Agreement (Visible to authorisers)
terms	Terms	true	No description

CreateOpenAgreementResponse

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "active",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "min_amount": null,
        "max_amount": 10000
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/aecff76d-13e0-4e17-b7c5-844ae07fa675/agreements/invitation"
  }
}

Properties

Create an Open Agreement (response)

Name	Type	Required	Description
data	object	true	No description

ListAllOpenAgreementsResponse

{
  "data": [
    {
      "ref": "OA.1",
      "title": "Subscription Plan A",
      "status": "active",
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      },
      "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
    },
    {
      "ref": "OA.2",
      "title": "Subscription Plan B",
      "status": "closed",
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": null,
          "max_amount": null
        }
      },
      "link": "https://go-sandbox.split.cash/open_agreements/948e3662-154d-42d1-bdc9-a05c251d3981/agreements/invitation"
    }
  ]
}

Properties

List all Open Agreements (response)

Name	Type	Required	Description
data	[object]	true	No description

ActivateOpenAgreementResponse

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "active",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
  }
}

Properties

Activate Open Agreement Request (response)

Name	Type	Required	Description
data	object	true	No description

CloseOpenAgreementResponse

{
  "data": {
    "ref": "OA.1",
    "title": "Subscription Plan A",
    "status": "closed",
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "link": "https://go-sandbox.split.cash/open_agreements/2e002c0b-ffaf-44eb-a35c-15fa384ddde1/agreements/invitation"
  }
}

Properties

Close Open Agreement Request (response)

Name	Type	Required	Description
data	object	true	No description

AddASplitContactRequest

{
  "nickname": "outstanding_tours"
}

Properties

Add a Split Contact (request)

Name	Type	Required	Description
nickname	string	true	Split account nickname

AddASplitContactResponse

{
  "data": {
    "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
    "name": "Outstanding Tours Pty Ltd",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "verified"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Properties

Add a Split Contact (response)

Name	Type	Required	Description
data	object	true	No description

ListAllContactsResponse

{
  "data": [
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "name": "Outstanding Tours Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": "095c5ab7-7fa8-40fd-b317-cddbbf4c8fbc",
        "account_number": "494307",
        "branch_code": "435434",
        "bank_name": "National Australia Bank",
        "state": "verified"
      },
      "account": {
        "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
        "nickname": "outstanding_tours",
        "abn": "123456789",
        "name": "Outstanding Tours Pty Ltd"
      }
    },
    {
      "id": "49935c67-c5df-4f00-99f4-1413c18a89a0",
      "name": "Adventure Dudes Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": "861ff8e4-7acf-4897-9e53-e7c5ae5f7cc0",
        "account_number": "4395959",
        "branch_code": "068231",
        "bank_name": "National Australia Bank",
        "state": "verified"
      },
      "account": {
        "id": "362f7fe8-4af2-4902-b3d7-b5ab704ef2e7",
        "nickname": "adventure_dudes",
        "abn": "126754389",
        "name": "Adventure Dudes Pty Ltd"
      }
    },
    {
      "id": "eb3266f9-e172-4b6c-b802-fe5ac4d3250a",
      "name": "Surfing World Pty Ltd",
      "email": "[email protected]",
      "type": "Split account",
      "bank_account": {
        "id": null,
        "account_number": null,
        "branch_code": null,
        "bank_name": null,
        "state": "disabled"
      },
      "account": {
        "id": "a31dc907-9c7a-4736-84c9-1149cf03de42",
        "nickname": "surfing_world",
        "abn": "295443789",
        "name": "Surfing World Pty Ltd"
      }
    },
    {
      "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
      "name": "Hunter Thompson",
      "email": "[email protected]",
      "type": "anyone",
      "bank_account": {
        "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
        "account_number": "13048322",
        "branch_code": "123456",
        "bank_name": "National Australia Bank",
        "state": "pending_verification"
      },
      "anyone_account": {
        "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d"
      }
    }
  ]
}

Properties

List all Contacts (response)

Name	Type	Required	Description
data	[object]	true	No description

AddAnAnyoneContactRequest

{
  "name": "Hunter Thompson",
  "email": "[email protected]",
  "branch_code": "123456",
  "account_number": "13048322"
}

Properties

Add an Anyone Contact (request)

Name	Type	Required	Description
name	string	true	The name of the Contact
email	string	true	The email of the Contact
branch_code	string	true	The bank account BSB of the Contact
account_number	string	true	The bank account number of the Contact

AddAnAnyoneContactResponse

{
  "data": {
    "id": "6a7ed958-f1e8-42dc-8c02-3901d7057357",
    "name": "Hunter Thompson",
    "email": "[email protected]",
    "type": "anyone",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "13048322",
      "branch_code": "123456",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "anyone_account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d"
    }
  }
}

Properties

Add an Anyone Contact (response)

Name	Type	Required	Description
data	object	true	No description

GetAContactResponse

{
  "data": {
    "id": "fcabeacb-2ef6-4b27-ba19-4f6fa0d57dcb",
    "name": "Outstanding Tours Pty Ltd",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Properties

Get a Contact (response)

Name	Type	Required	Description
data	object	true	No description

UpdateAContactRequest

{
  "name": "My very own alias"
}

Properties

Update a Contact (request)

Name	Type	Required	Description
name	string	true	The name of the Contact

UpdateAContactResponse

{
  "data": {
    "id": "fcabeacb-2ef6-4b27-ba19-4f6fa0d57dcb",
    "name": "My very own alias",
    "email": "[email protected]",
    "type": "Split account",
    "bank_account": {
      "id": "55afddde-4296-4daf-8e49-7ba481ef9608",
      "account_number": "947434694",
      "branch_code": "304304",
      "bank_name": "National Australia Bank",
      "state": "pending_verification"
    },
    "account": {
      "id": "77be6ecc-5fa7-454b-86d6-02a5f147878d",
      "nickname": "outstanding_tours",
      "abn": "123456789",
      "name": "Outstanding Tours Pty Ltd"
    }
  }
}

Properties

Update a Contact (response)

Name	Type	Required	Description
data	object	true	No description

MakeAPaymentRequest

{
  "description": "The SuperPackage",
  "matures_at": "2016-09-13T00:00:00Z",
  "payouts": [
    {
      "amount": 30000,
      "description": "A tandem skydive jump SB23094",
      "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
      "metadata": {
        "invoice_ref": "BILL-0001",
        "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    },
    {
      "amount": 30000,
      "description": "A scuba dive SDS5464",
      "recipient_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
    }
  ],
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Properties

Make a Payment (request)

Name	Type	Required	Description
description	string	true	User description. Only visible to the payer
matures_at	string	true	Date & time in UTC ISO8601 the Payment should be processed
payouts	[Payout]	true	One or many Payouts
metadata	Metadata	false	No description

Payout

{
  "amount": 30000,
  "description": "A tandem skydive jump SB23094",
  "recipient_id": "48b89364-1577-4c81-ba02-96705895d457",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Properties

The actual Payout

Name	Type	Required	Description
amount	number	true	Amount in cents to pay the recipient
description	string	true	Description that both the payer an recipient can see
recipient_id	string	true	Contact bank account to pay (`Contact.data.bank_account.id`)
metadata	Metadata	false	No description

Metadata

{
  "custom_key": "Custom string",
  "another_custom_key": "Maybe a URL"
}

Properties

Use for your custom data an certain Split customisations

None

MakeAPaymentResponse

{
  "data": {
    "ref": "PB.1",
    "payouts": [
      {
        "ref": "D.1",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A tandem skydive jump SB23094",
        "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
        "to_id": "48b89364-1577-4c81-ba02-96705895d457",
        "metadata": {
          "invoice_ref": "BILL-0001",
          "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
          "custom_key": "Custom string",
          "another_custom_key": "Maybe a URL"
        }
      },
      {
        "ref": "D.2",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A scuba dive SDS5464",
        "from_id": "48b89364-1577-4c81-ba02-96705895d457",
        "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
      }
    ],
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Make a Payment (response)

Name	Type	Required	Description
data	object	true	No description

ApprovePaymentRequestResponse

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "debit_ref": "D.b",
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Approve Payment Request (response)

Name	Type	Required	Description
data	object	true	No description

DeclinePaymentRequestResponse

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "declined",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "debit_ref": null,
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Decline a Payment Request (response)

Name	Type	Required	Description
data	object	true	No description

ListAllPaymentsResponse

{
  "data": [
    {
      "ref": "PB.1",
      "payouts": [
        {
          "ref": "D.1",
          "batch_description": "This description is only available to the payer",
          "matures_at": "2016-09-13T23:50:44Z",
          "created_at": "2016-09-10T23:50:44Z",
          "status": "maturing",
          "amount": 30000,
          "description": "The recipient will see this description",
          "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
          "to_id": "48b89364-1577-4c81-ba02-96705895d457",
          "metadata": {
            "invoice_ref": "BILL-0001",
            "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
            "custom_key": "Custom string",
            "another_custom_key": "Maybe a URL"
          }
        },
        {
          "ref": "D.2",
          "batch_description": "This description is only available to the payer",
          "matures_at": "2016-09-13T23:50:44Z",
          "created_at": "2016-09-10T23:50:44Z",
          "status": "maturing",
          "amount": 30000,
          "description": "The recipient will see this description",
          "from_id": "48b89364-1577-4c81-ba02-96705895d457",
          "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
        }
      ],
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List all Payments (response)

Name	Type	Required	Description
data	[object]	true	No description

GetAPaymentResponse

{
  "data": {
    "ref": "PB.1",
    "payouts": [
      {
        "ref": "D.1",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44",
        "status": "maturing",
        "amount": 30000,
        "description": "A tandem skydive jump SB23094",
        "from_id": "83623359-e86e-440c-9780-432a3bc3626f",
        "to_id": "48b89364-1577-4c81-ba02-96705895d457",
        "metadata": {
          "invoice_ref": "BILL-0001",
          "invoice_id": "c80a9958-e805-47c0-ac2a-c947d7fd778d",
          "custom_key": "Custom string",
          "another_custom_key": "Maybe a URL"
        }
      },
      {
        "ref": "D.2",
        "batch_description": "The SuperPackage",
        "matures_at": "2016-09-13T23:50:44Z",
        "created_at": "2016-09-10T23:50:44Z",
        "status": "maturing",
        "amount": 30000,
        "description": "A scuba dive SDS5464",
        "from_id": "48b89364-1577-4c81-ba02-96705895d457",
        "to_id": "dc6f1e60-3803-43ca-a200-7d641816f57f"
      }
    ],
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Get a Payment (response)

Name	Type	Required	Description
data	object	true	No description

MakeAPaymentRequestRequest

{
  "description": "Visible to both initiator and authoriser",
  "matures_at": "12/19/2016 2:10:56 AM",
  "amount": 99000,
  "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Properties

Make a Payment Request (request)

Name	Type	Required	Description
description	string	true	Description visible to the initiator (payee) & authoriser (payer)
matures_at	string	true	Date & time in UTC ISO8601 that the Payment will be processed if the request is approved
amount	number	true	Amount in cents to pay the initiator
authoriser_id	string	true	The Contact bank account that will be used to pay the PR (`Contact.data.bank_account.id`)'
metadata	Metadata	false	No description

MakeAPaymentRequestResponse

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "de86472c-c027-4735-a6a7-234366a27fc7",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T02:10:56Z",
    "credit_ref": null,
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Make a Payment Request (response)

Name	Type	Required	Description
data	object	true	No description

GetAPaymentRequestResponse

{
  "data": {
    "ref": "PR.3",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T02:38:04Z",
    "created_at": "2016-12-19T02:10:56Z",
    "credit_ref": "C.b",
    "payout": {
      "amount": 99000,
      "description": "The elite package for 4",
      "matures_at": "2016-12-25T00:00:00Z"
    },
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Get a Payment Request (response)

Name	Type	Required	Description
data	object	true	No description

ListIncomingPaymentRequestsResponse

{
  "data": [
    {
      "ref": "PR.2",
      "initiator_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "authoriser_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "status": "approved",
      "responded_at": "2016-12-19T02:10:18Z",
      "created_at": "2016-12-19T02:09:09Z",
      "debit_ref": "D.a",
      "payout": {
        "amount": 30000,
        "description": "The SuperPackage",
        "matures_at": "2016-12-20T00:00:00Z"
      }
    },
    {
      "ref": "PR.3",
      "initiator_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "authoriser_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T02:10:56Z",
      "debit_ref": null,
      "payout": {
        "amount": 99000,
        "description": "The elite package for 4",
        "matures_at": "2016-12-25T00:00:00Z"
      },
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List incoming Payment Requests (response)

Name	Type	Required	Description
data	[object]	true	No description

ListOutgoingPaymentRequestsResponse

{
  "data": [
    {
      "ref": "PR.4",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "approved",
      "responded_at": "2016-12-19T02:10:18Z",
      "created_at": "2016-12-19T02:09:09Z",
      "credit_ref": "C.a",
      "payout": {
        "amount": 30000,
        "description": "The SuperPackage",
        "matures_at": "2016-12-20T00:00:00Z"
      }
    },
    {
      "ref": "PR.5",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T02:10:56Z",
      "credit_ref": null,
      "payout": {
        "amount": 99000,
        "description": "The elite package for 4",
        "matures_at": "2016-12-25T00:00:00Z"
      }
    }
  ]
}

Properties

List outgoing Payment Requests (response)

Name	Type	Required	Description
data	[object]	true	No description

GetAPaymentRequestsHistoryResponse

{
  "data": [
    {
      "type": "payout_request",
      "event": "requested",
      "at": "2017-01-05T07:47:45Z",
      "ref": "PR.3",
      "by": "Fancy Pants (fancy_pants)"
    },
    {
      "type": "payout_request",
      "event": "approved",
      "at": "2017-01-07T06:13:52Z",
      "ref": "PR.3",
      "by": "Lycra Co (lycra_co)"
    },
    {
      "type": "debit",
      "event": "scheduled",
      "at": "2017-01-07T06:13:52Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "scheduled",
      "at": "2017-01-07T06:13:52Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "matured",
      "at": "2017-01-08T04:30:14Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "processing",
      "at": "2017-01-08T04:30:14Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "clearing",
      "at": "2017-01-08T19:02:20Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "debit",
      "event": "cleared",
      "at": "2017-01-11T19:07:52Z",
      "ref": "D.n",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "matured",
      "at": "2017-01-11T19:07:52Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "processing",
      "at": "2017-01-12T04:30:25Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "clearing",
      "at": "2017-01-12T05:17:32Z",
      "ref": "C.e",
      "by": "Split Payments"
    },
    {
      "type": "credit",
      "event": "cleared",
      "at": "2017-01-15T05:27:12Z",
      "ref": "C.e",
      "by": "Split Payments"
    }
  ]
}

Properties

Get a Payment Request's history (response)

Name	Type	Required	Description
data	[object]	true	No description

IssueARefundRequest

{
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Properties

Issue a Refund (request)

Name	Type	Required	Description
amount	number	true	Amount in cents refund
reason	string	false	Reason for the refund. Visible to both parties.
metadata	Metadata	false	No description

IssueARefundResponse

{
  "data": {
    "ref": "PRF.1",
    "for_ref": "C.59",
    "debit_ref": "D.hi",
    "created_at": "2017-05-08T07:20:24Z",
    "amount": 500,
    "reason": "Because reason",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Issue a Refund (response)

Name	Type	Required	Description
data	object	true	No description

ListIncomingRefundsResponse

{
  "data": [
    {
      "ref": "PRF.2",
      "for_ref": "D.5",
      "credit_ref": "C.q",
      "created_at": "2017-05-09T04:45:26Z",
      "amount": 5,
      "reason": "Because reason",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List incoming Refunds (response)

Name	Type	Required	Description
data	[object]	true	No description

ListOutgoingRefundsResponse

{
  "data": [
    {
      "ref": "PRF.2",
      "for_ref": "C.5",
      "debit_ref": "D.5a",
      "created_at": "2017-05-09T04:45:26Z",
      "amount": 5,
      "reason": "Because reason",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List outgoing Refunds (response)

Name	Type	Required	Description
data	[object]	true	No description

RetrieveARefundResponse

{
  "data": {
    "ref": "PRF.1",
    "for_ref": "C.59",
    "debit_ref": "D.hi",
    "created_at": "2017-05-08T07:20:24Z",
    "amount": 500,
    "reason": "Because reason",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Retrieve a Refund (response)

Name	Type	Required	Description
data	object	true	No description

RequestARefundRequest

{
  "for_ref": "D.1",
  "amount": 500,
  "reason": "Because reason",
  "metadata": {
    "custom_key": "Custom string",
    "another_custom_key": "Maybe a URL"
  }
}

Properties

Request a Refund (request)

Name	Type	Required	Description
for_ref	string	true	The Payout debit reference to refund against
amount	number	true	Amount in cents to request from the original payout recipient
reason	string	false	Reason for the refund request. Visible to both parties.
metadata	Metadata	false	No description

RequestARefundResponse

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "credit_ref": null,
    "amount": 500,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Request a Refund (response)

Name	Type	Required	Description
data	object	true	No description

RetrieveARefundRequestResponse

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "pending_approval",
    "responded_at": null,
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "credit_ref": null,
    "amount": 10000,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Retrieve a Refund Request (response)

Name	Type	Required	Description
data	object	true	No description

ApprovePayoutRefundRequestResponse

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "approved",
    "responded_at": "2016-12-19T04:42:59Z",
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "C.1",
    "debit_ref": "D.2c3",
    "amount": 100,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Approve a Refund Request (response)

Name	Type	Required	Description
data	object	true	No description

DeclinePayoutRefundRequestResponse

{
  "data": {
    "ref": "RR.2",
    "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
    "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
    "status": "declined",
    "responded_at": "2016-12-19T04:42:59Z",
    "created_at": "2016-12-19T04:34:38Z",
    "for_ref": "D.1",
    "debit_ref": null,
    "amount": 100,
    "reason": "Because reasons",
    "metadata": {
      "custom_key": "Custom string",
      "another_custom_key": "Maybe a URL"
    }
  }
}

Properties

Decline a Refund Request (response)

Name	Type	Required	Description
data	object	true	No description

ListIncomingRefundRequestsResponse

{
  "data": [
    {
      "ref": "RR.2",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "approved",
      "responded_at": "2016-12-19T04:42:59Z",
      "created_at": "2016-12-19T04:34:38Z",
      "for_ref": "C.1",
      "debit_ref": "D.2c3",
      "amount": 100,
      "reason": "Because reasons",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List incoming Refund Requests (response)

Name	Type	Required	Description
data	[object]	true	No description

ListOutgoingRefundRequestsResponse

{
  "data": [
    {
      "ref": "RR.2",
      "initiator_id": "ca7bc5b3-e47f-4153-96fb-bbe326b42772",
      "authoriser_id": "fb6a9252-3818-44dc-b5aa-2195391a746f",
      "status": "pending_approval",
      "responded_at": null,
      "created_at": "2016-12-19T04:34:38Z",
      "for_ref": "D.1",
      "credit_ref": null,
      "amount": 10000,
      "reason": "Because reasons",
      "metadata": {
        "custom_key": "Custom string",
        "another_custom_key": "Maybe a URL"
      }
    }
  ]
}

Properties

List outgoing Refund Requests (response)

Name	Type	Required	Description
data	[object]	true	No description

ListAllTransactionsResponse

{
  "data": [
    {
      "ref": "D.3",
      "parent_ref": null,
      "type": "debit",
      "category": "payout_refund",
      "created_at": "2016-12-07T23:15:00Z",
      "matures_at": "2016-12-10T23:15:00Z",
      "cleared_at": "2016-12-10T23:15:00Z",
      "bank_ref": "DT.9a",
      "status": "Cleared",
      "party_name": "Sanford-Rees",
      "party_nickname": null,
      "party_bank_ref": "CT.11",
      "description": null,
      "amount": 1
    },
    {
      "ref": "D.2",
      "parent_ref": "PB.2",
      "type": "debit",
      "category": "payout",
      "created_at": "2016-12-06T23:15:00Z",
      "matures_at": "2016-12-09T23:15:00Z",
      "cleared_at": null,
      "bank_ref": null,
      "status": " Pending",
      "party_name": "Gutmann-Schmidt",
      "party_nickname": null,
      "party_bank_ref": null,
      "description": "Batteries for hire",
      "amount": 1
    },
    {
      "ref": "C.2",
      "parent_ref": null,
      "type": "credit",
      "category": "payout",
      "created_at": "2016-12-05T23:15:00Z",
      "matures_at": "2016-12-06T23:15:00Z",
      "cleared_at": "2016-12-09T23:15:00Z",
      "bank_ref": "CT.1",
      "status": "Pending",
      "party_name": "Price and Sons",
      "party_nickname": "price-and-sons-2",
      "party_bank_ref": null,
      "description": "Money for jam",
      "amount": 1
    }
  ]
}

Properties

List all transactions (response)

Name	Type	Required	Description
data	[object]	true	No description

ProposeUnassignedAgreementRequest

{
  "expiry_in_seconds": 60,
  "terms": {
    "per_payout": {
      "min_amount": null,
      "max_amount": 10000
    },
    "per_frequency": {
      "days": 7,
      "max_amount": 1000000
    }
  }
}

Properties

Propose an Unassigned Agreement (request)

Name	Type	Required	Description
expiry_in_seconds	number	true	The amount of time in seconds before the Unassigned Agreement can no longer be accepted.
terms	Terms	true	No description

ProposeUnassignedAgreementResponse

{
  "data": {
    "ref": "A.4k",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "assignment_expires_at": "2017-03-20T00:54:27Z",
    "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
  }
}

Properties

Propose an Unassigned Agreement (response)

Name	Type	Required	Description
data	object	true	No description

ListUnassignedAgreementsResponse

{
  "data": [
    {
      "ref": "A.4k",
      "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-20T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": 10000,
          "min_amount": null
        },
        "per_frequency": {
          "days": 7,
          "max_amount": 1000000
        }
      },
      "assignment_expires_at": "2017-03-20T00:54:27Z",
      "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
    },
    {
      "ref": "A.7ea",
      "initiator_id": "b61fc159-8779-4a17-a826-e398e3e7e211",
      "status": "proposed",
      "responded_at": null,
      "created_at": "2017-03-21T00:53:27Z",
      "terms": {
        "per_payout": {
          "max_amount": null,
          "min_amount": null
        },
        "per_frequency": {
          "days": null,
          "max_amount": null
        }
      },
      "assignment_expires_at": "2017-03-21T00:54:27Z",
      "link": "https://go-sandbox.split.cash/unassigned_agreements/4e2728cc-b4ba-42c2-a6c3-26a7758de58d/invitation"
    }
  ]
}

Properties

List Unassigned Agreements (response)

Name	Type	Required	Description
data	[object]	true	No description

GetUnassignedAgreementResponse

{
  "data": {
    "ref": "A.4k",
    "initiator_id": "4e2728cc-b4ba-42c2-a6c3-26a7758de58d",
    "status": "proposed",
    "responded_at": null,
    "created_at": "2017-03-20T00:53:27Z",
    "terms": {
      "per_payout": {
        "max_amount": 10000,
        "min_amount": null
      },
      "per_frequency": {
        "days": 7,
        "max_amount": 1000000
      }
    },
    "assignment_expires_at": "2017-03-20T00:54:27Z",
    "link": "https://go-sandbox.split.cash/unassigned_agreements/b61fc159-8779-4a17-a826-e398e3e7e211/invitation"
  }
}

Properties

Get an Unassigned Agreement (response)

Name	Type	Required	Description
data	object	true	No description

GetUserDetailsResponse

{
  "data": {
    "first_name": "Bear",
    "last_name": "Dog",
    "mobile_phone": "0456945832",
    "email": "[email protected]",
    "account": {
      "name": "Dog Bones Inc",
      "nickname": "dog-bones-inc",
      "abn": "129959040",
      "phone": "0418495033",
      "street_address": "98 Acme Avenue",
      "suburb": "Lead",
      "state": "NSW",
      "postcode": "2478"
    }
  }
}

Properties

Get User details (response)

Name	Type	Required	Description
data	object	true	No description

Split API v1.0

Guides

Try it out

Get started

Authentication and Authorisation

Authorisation Code Grant

Refresh Token Grant

Making payments

Getting paid

POSTing a Payment Request

Sharing an Open Payment Request

Idempotent requests

Speeding up onboarding

Testing details

Configuration

Scopes

Pagination

Remitter

Webhooks

Agreements

Lifecycle

Propose an Agreement

Parameters

Responses

Approve an Agreement

Parameters

Responses

Decline and Agreement

Parameters

Responses

Get an Agreement

Parameters

Responses

Cancel an Agreement

Parameters

Responses

List incoming Agreements

Parameters

Enumerated Values

Responses

List outgoing Agreements

Parameters

Enumerated Values

Responses

Bank Accounts

List all Bank Accounts

Responses

Contacts

Add a Split Contact

Parameters

Responses

List all Contacts

Parameters

Responses

Add an Anyone Contact

Parameters

Responses

Get a Contact

Parameters

Responses

Remove a Contact

Parameters

Responses

Update a Contact

Parameters

Responses

Open Agreements

Lifecycle

Create an Open Agreement

Parameters

Responses

List all Open Agreements

Parameters

Responses

Activate a closed Open Agreement

Parameters

Responses

Close an active Open Agreement

Parameters

Responses