NAV Navbar
Symmetrical
Shell HTTP JavaScript Node.JS Ruby Python Java Go

sym-poc API v1

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

Authentication

auction

auction_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/auction/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/auction/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/auction/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/auction/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/auction/", data)
    req.Header = headers

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

GET /auction/

Parameters

Name In Type Required Description
ordering query string false Which field to use when ordering the results.
order query string false none
status query string false none

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "id",
      "auction_end"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "Id",
        "type": "string",
        "format": "uuid"
      },
      "order": {
        "title": "Order",
        "required": [
          "id",
          "user",
          "notional"
        ],
        "type": "object",
        "properties": {
          "id": {
            "title": "Id",
            "type": "string",
            "format": "uuid"
          },
          "user": {
            "title": "User",
            "type": "integer"
          },
          "product": {
            "title": "Product",
            "required": [
              "risk_attributes",
              "name",
              "description"
            ],
            "type": "object",
            "properties": {
              "id": {
                "title": "ID",
                "type": "integer",
                "readOnly": true
              },
              "risk_attributes": {
                "title": "Risk attributes",
                "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
                "type": "string",
                "minLength": 1
              },
              "cash_flow_schedule": {
                "title": "Cash flow schedule",
                "type": "string",
                "nullable": true
              },
              "events_of_default": {
                "title": "Events of default",
                "type": "string",
                "nullable": true
              },
              "name": {
                "title": "Name",
                "type": "string",
                "maxLength": 45,
                "minLength": 1
              },
              "description": {
                "title": "Description",
                "type": "string",
                "maxLength": 200,
                "minLength": 1
              },
              "duration": {
                "title": "Duration",
                "type": "integer",
                "maximum": 2147483647,
                "minimum": -2147483648
              },
              "category": {
                "title": "Category",
                "type": "integer",
                "enum": [
                  0,
                  1,
                  2
                ]
              },
              "auction_duration": {
                "title": "Auction duration",
                "type": "number"
              }
            }
          },
          "created": {
            "title": "Created",
            "type": "string",
            "format": "date-time",
            "readOnly": true
          },
          "status": {
            "title": "Status",
            "type": "string",
            "readOnly": true
          },
          "notional": {
            "title": "Notional",
            "type": "string",
            "format": "decimal"
          },
          "auction_id": {
            "title": "Auction id",
            "type": "string",
            "readOnly": true
          }
        }
      },
      "auction_end": {
        "title": "Auction end",
        "type": "string",
        "format": "date-time"
      },
      "created": {
        "title": "Created",
        "type": "string",
        "format": "date-time",
        "readOnly": true
      },
      "dsp_confirmation": {
        "title": "Dsp confirmation",
        "type": "string",
        "format": "date-time",
        "nullable": true
      },
      "status": {
        "title": "Status",
        "type": "string",
        "readOnly": true
      },
      "offers_count": {
        "title": "Offers count",
        "type": "string",
        "readOnly": true
      },
      "price": {
        "title": "Price",
        "type": "string",
        "readOnly": true
      },
      "winning_offer": {
        "title": "Winning offer",
        "type": "string",
        "format": "uuid",
        "readOnly": true
      },
      "customer_risk_attributes": {
        "title": "Customer risk attributes",
        "type": "string",
        "readOnly": true
      },
      "my_offer_is_winning": {
        "title": "My offer is winning",
        "type": "string",
        "readOnly": true
      },
      "i_am_bidding": {
        "title": "I am bidding",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Auction] false none none
» id string(uuid) true none none
» order Order false none none
»» id string(uuid) true none none
»» user integer true none none
»» product Product false none none
»»» id integer false read-only none
»»» risk_attributes string true none It has to be JSON according to the following schema: {"type": "array", "items": {"type": "object", "properties": {"key": {"type": "string"}, "mandatory": {"type": "boolean"}, "type": {"enum": ["number", "string", "array"]}, "array_for_select": {"type": "array"}, "personal": {"type": "boolean"}, "source": {"enum": ["DSP", "customer"]}, "label": {"type": "string"}}, "if": {"properties": {"type": {"enum": ["array"]}}}, "then": {"required": ["key", "mandatory", "type", "array_for_select", "personal", "source", "label"], "properties": {"array_for_select": {"type": "array", "minItems": 1}}}, "else": {"required": ["key", "mandatory", "type", "personal", "source", "label"]}}}
»»» cash_flow_schedule string\ null false none
»»» events_of_default string\ null false none
»»» name string true none none
»»» description string true none none
»»» duration integer false none none
»»» category integer false none none
»»» auction_duration number false none none
»» created string(date-time) false read-only none
»» status string false read-only none
»» notional string(decimal) true none none
»» auction_id string false read-only none
» auction_end string(date-time) true none none
» created string(date-time) false read-only none
» dsp_confirmation string(date-time)\ null false none
» status string false read-only none
» offers_count string false read-only none
» price string false read-only none
» winning_offer string(uuid) false read-only none
» customer_risk_attributes string false read-only none
» my_offer_is_winning string false read-only none
» i_am_bidding string false read-only none

Enumerated Values

Property Value
category 0
category 1
category 2

auction_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/auction/{external_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/auction/{external_id}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/{external_id}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/{external_id}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/auction/{external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/auction/{external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/{external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/auction/{external_id}/", data)
    req.Header = headers

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

GET /auction/{external_id}/

Parameters

Name In Type Required Description
external_id path string(uuid) true none

Example responses

200 Response

{
  "required": [
    "id",
    "auction_end"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "auction_end": {
      "title": "Auction end",
      "type": "string",
      "format": "date-time"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "dsp_confirmation": {
      "title": "Dsp confirmation",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "offers_count": {
      "title": "Offers count",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "winning_offer": {
      "title": "Winning offer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "customer_risk_attributes": {
      "title": "Customer risk attributes",
      "type": "string",
      "readOnly": true
    },
    "my_offer_is_winning": {
      "title": "My offer is winning",
      "type": "string",
      "readOnly": true
    },
    "i_am_bidding": {
      "title": "I am bidding",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Auction

auction_confirm_auction_terms

Code samples

# You can also use wget
curl -X POST http://testserver/v1/auction/{external_id}/confirm/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/auction/{external_id}/confirm/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/{external_id}/confirm/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "id",
    "auction_end"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "auction_end": {
      "title": "Auction end",
      "type": "string",
      "format": "date-time"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "dsp_confirmation": {
      "title": "Dsp confirmation",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "offers_count": {
      "title": "Offers count",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "winning_offer": {
      "title": "Winning offer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "customer_risk_attributes": {
      "title": "Customer risk attributes",
      "type": "string",
      "readOnly": true
    },
    "my_offer_is_winning": {
      "title": "My offer is winning",
      "type": "string",
      "readOnly": true
    },
    "i_am_bidding": {
      "title": "I am bidding",
      "type": "string",
      "readOnly": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/{external_id}/confirm/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/auction/{external_id}/confirm/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/auction/{external_id}/confirm/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/{external_id}/confirm/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/auction/{external_id}/confirm/", data)
    req.Header = headers

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

POST /auction/{external_id}/confirm/

Body parameter

{
  "required": [
    "id",
    "auction_end"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "auction_end": {
      "title": "Auction end",
      "type": "string",
      "format": "date-time"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "dsp_confirmation": {
      "title": "Dsp confirmation",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "offers_count": {
      "title": "Offers count",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "winning_offer": {
      "title": "Winning offer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "customer_risk_attributes": {
      "title": "Customer risk attributes",
      "type": "string",
      "readOnly": true
    },
    "my_offer_is_winning": {
      "title": "My offer is winning",
      "type": "string",
      "readOnly": true
    },
    "i_am_bidding": {
      "title": "I am bidding",
      "type": "string",
      "readOnly": true
    }
  }
}

Parameters

Name In Type Required Description
body body Auction true none
external_id path string(uuid) true none

Example responses

201 Response

{
  "required": [
    "id",
    "auction_end"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "auction_end": {
      "title": "Auction end",
      "type": "string",
      "format": "date-time"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "dsp_confirmation": {
      "title": "Dsp confirmation",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "offers_count": {
      "title": "Offers count",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "winning_offer": {
      "title": "Winning offer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "customer_risk_attributes": {
      "title": "Customer risk attributes",
      "type": "string",
      "readOnly": true
    },
    "my_offer_is_winning": {
      "title": "My offer is winning",
      "type": "string",
      "readOnly": true
    },
    "i_am_bidding": {
      "title": "I am bidding",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created Auction

auction_offer_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/auction/{external_id}/offer/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/auction/{external_id}/offer/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/{external_id}/offer/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/{external_id}/offer/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/auction/{external_id}/offer/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/auction/{external_id}/offer/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/{external_id}/offer/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/auction/{external_id}/offer/", data)
    req.Header = headers

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

GET /auction/{external_id}/offer/

Parameters

Name In Type Required Description
ordering query string false Which field to use when ordering the results.
external_id path string true none

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "id",
      "notional"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "Id",
        "type": "string",
        "format": "uuid"
      },
      "notional": {
        "title": "Notional",
        "type": "string",
        "format": "decimal"
      },
      "price": {
        "title": "Price",
        "type": "string",
        "readOnly": true
      },
      "status": {
        "title": "Status",
        "type": "string",
        "readOnly": true
      },
      "created": {
        "title": "Created",
        "type": "string",
        "format": "date-time",
        "readOnly": true
      },
      "probability_of_default": {
        "title": "Probability of default",
        "type": "number",
        "nullable": true
      },
      "loss_given_default": {
        "title": "Loss given default",
        "type": "number",
        "nullable": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Offer] false none none
» id string(uuid) true none none
» notional string(decimal) true none none
» price string false read-only none
» status string false read-only none
» created string(date-time) false read-only none
» probability_of_default number\ null false none
» loss_given_default number\ null false none

auction_offer_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/auction/{external_id}/offer/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/auction/{external_id}/offer/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/{external_id}/offer/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "id",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "probability_of_default": {
      "title": "Probability of default",
      "type": "number",
      "nullable": true
    },
    "loss_given_default": {
      "title": "Loss given default",
      "type": "number",
      "nullable": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/{external_id}/offer/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/auction/{external_id}/offer/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/auction/{external_id}/offer/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/{external_id}/offer/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/auction/{external_id}/offer/", data)
    req.Header = headers

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

POST /auction/{external_id}/offer/

Body parameter

{
  "required": [
    "id",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "probability_of_default": {
      "title": "Probability of default",
      "type": "number",
      "nullable": true
    },
    "loss_given_default": {
      "title": "Loss given default",
      "type": "number",
      "nullable": true
    }
  }
}

Parameters

Name In Type Required Description
body body Offer true none
external_id path string true none

Example responses

201 Response

{
  "required": [
    "id",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "probability_of_default": {
      "title": "Probability of default",
      "type": "number",
      "nullable": true
    },
    "loss_given_default": {
      "title": "Loss given default",
      "type": "number",
      "nullable": true
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created Offer

auction_read_auction_terms

Code samples

# You can also use wget
curl -X GET http://testserver/v1/auction/{external_id}/terms/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/auction/{external_id}/terms/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auction/{external_id}/terms/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auction/{external_id}/terms/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/auction/{external_id}/terms/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/auction/{external_id}/terms/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auction/{external_id}/terms/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/auction/{external_id}/terms/", data)
    req.Header = headers

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

GET /auction/{external_id}/terms/

Parameters

Name In Type Required Description
external_id path string(uuid) true none

Example responses

200 Response

{
  "required": [
    "id",
    "auction_end"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "auction_end": {
      "title": "Auction end",
      "type": "string",
      "format": "date-time"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "dsp_confirmation": {
      "title": "Dsp confirmation",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "offers_count": {
      "title": "Offers count",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "winning_offer": {
      "title": "Winning offer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "customer_risk_attributes": {
      "title": "Customer risk attributes",
      "type": "string",
      "readOnly": true
    },
    "my_offer_is_winning": {
      "title": "My offer is winning",
      "type": "string",
      "readOnly": true
    },
    "i_am_bidding": {
      "title": "I am bidding",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Auction

auth

auth_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/auth \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/auth HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auth',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "username",
    "password"
  ],
  "type": "object",
  "properties": {
    "username": {
      "title": "Username",
      "type": "string",
      "minLength": 1
    },
    "password": {
      "title": "Password",
      "type": "string",
      "minLength": 1
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auth',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/auth',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/auth', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auth");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/auth", data)
    req.Header = headers

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

POST /auth

Takes a set of user credentials and returns an access and refresh JSON web token pair to prove the authentication of those credentials.

Body parameter

{
  "required": [
    "username",
    "password"
  ],
  "type": "object",
  "properties": {
    "username": {
      "title": "Username",
      "type": "string",
      "minLength": 1
    },
    "password": {
      "title": "Password",
      "type": "string",
      "minLength": 1
    }
  }
}

Parameters

Name In Type Required Description
body body TokenObtainPair true none

Example responses

201 Response

{
  "required": [
    "username",
    "password"
  ],
  "type": "object",
  "properties": {
    "username": {
      "title": "Username",
      "type": "string",
      "minLength": 1
    },
    "password": {
      "title": "Password",
      "type": "string",
      "minLength": 1
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created TokenObtainPair

auth_api_key_login_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/auth/api_key_login \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/auth/api_key_login HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auth/api_key_login',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "bot's api_key",
      "type": "string"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auth/api_key_login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/auth/api_key_login',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/auth/api_key_login', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auth/api_key_login");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/auth/api_key_login", data)
    req.Header = headers

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

POST /auth/api_key_login

Body parameter

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "bot's api_key",
      "type": "string"
    }
  }
}

Parameters

Name In Type Required Description
body body object true none
» api_key body string false bot's api_key

Example responses

201 Response

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "bot's api_key",
      "type": "string"
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created Inline

Response Schema

Status Code 201

Name Type Required Restrictions Description
» api_key string false none bot's api_key

auth_refresh_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/auth/refresh \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/auth/refresh HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/auth/refresh',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "refresh"
  ],
  "type": "object",
  "properties": {
    "refresh": {
      "title": "Refresh",
      "type": "string",
      "minLength": 1
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/auth/refresh',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/auth/refresh',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/auth/refresh', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/auth/refresh");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/auth/refresh", data)
    req.Header = headers

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

POST /auth/refresh

Takes a refresh type JSON web token and returns an access type JSON web token if the refresh token is valid.

Body parameter

{
  "required": [
    "refresh"
  ],
  "type": "object",
  "properties": {
    "refresh": {
      "title": "Refresh",
      "type": "string",
      "minLength": 1
    }
  }
}

Parameters

Name In Type Required Description
body body TokenRefresh true none

Example responses

201 Response

{
  "required": [
    "refresh"
  ],
  "type": "object",
  "properties": {
    "refresh": {
      "title": "Refresh",
      "type": "string",
      "minLength": 1
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created TokenRefresh

customer

customer_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/customer/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/customer/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/customer/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/customer/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/customer/", data)
    req.Header = headers

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

GET /customer/

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "first_names",
      "last_name",
      "pesel_number",
      "id_valid_until",
      "card_valid_until",
      "card_number",
      "card_owner"
    ],
    "type": "object",
    "properties": {
      "first_names": {
        "title": "First names",
        "type": "string",
        "maxLength": 128,
        "minLength": 1
      },
      "last_name": {
        "title": "Last name",
        "type": "string",
        "maxLength": 128,
        "minLength": 1
      },
      "pesel_number": {
        "title": "Pesel number",
        "type": "string",
        "maxLength": 11,
        "minLength": 1
      },
      "id_valid_until": {
        "title": "Id valid until",
        "type": "string",
        "format": "date-time"
      },
      "card_valid_until": {
        "title": "Card valid until",
        "type": "string",
        "format": "date-time"
      },
      "card_number": {
        "title": "Card number",
        "type": "string",
        "maxLength": 20,
        "minLength": 1
      },
      "card_owner": {
        "title": "Card owner",
        "type": "string",
        "maxLength": 256,
        "minLength": 1
      },
      "customer": {
        "title": "Customer",
        "type": "string",
        "format": "uuid",
        "readOnly": true
      },
      "address": {
        "title": "Address",
        "type": "string",
        "maxLength": 128,
        "nullable": true
      },
      "city": {
        "title": "City",
        "type": "string",
        "maxLength": 128,
        "nullable": true
      },
      "zip": {
        "title": "Zip",
        "type": "string",
        "maxLength": 11,
        "nullable": true
      },
      "email": {
        "title": "Email",
        "type": "string",
        "maxLength": 128,
        "nullable": true
      },
      "phone": {
        "title": "Phone",
        "type": "string",
        "maxLength": 12,
        "nullable": true
      },
      "payday_loan_count": {
        "title": "Payday loan count",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [CustomerData] false none none
» first_names string true none none
» last_name string true none none
» pesel_number string true none none
» id_valid_until string(date-time) true none none
» card_valid_until string(date-time) true none none
» card_number string true none none
» card_owner string true none none
» customer string(uuid) false read-only none
» address string\ null false none
» city string\ null false none
» zip string\ null false none
» email string\ null false none
» phone string\ null false none
» payday_loan_count string false read-only none

customer_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/customer/{customer__external_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/customer/{customer__external_id}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer/{customer__external_id}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer/{customer__external_id}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/customer/{customer__external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/customer/{customer__external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer/{customer__external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/customer/{customer__external_id}/", data)
    req.Header = headers

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

GET /customer/{customer__external_id}/

Parameters

Name In Type Required Description
customer__external_id path string true none

Example responses

200 Response

{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK CustomerData

customer_update

Code samples

# You can also use wget
curl -X PUT http://testserver/v1/customer/{customer__external_id}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT http://testserver/v1/customer/{customer__external_id}/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer/{customer__external_id}/',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer/{customer__external_id}/',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'http://testserver/v1/customer/{customer__external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://testserver/v1/customer/{customer__external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer/{customer__external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://testserver/v1/customer/{customer__external_id}/", data)
    req.Header = headers

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

PUT /customer/{customer__external_id}/

Body parameter

{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}

Parameters

Name In Type Required Description
body body CustomerData true none
customer__external_id path string true none

Example responses

200 Response

{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK CustomerData

customer_partial_update

Code samples

# You can also use wget
curl -X PATCH http://testserver/v1/customer/{customer__external_id}/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PATCH http://testserver/v1/customer/{customer__external_id}/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer/{customer__external_id}/',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer/{customer__external_id}/',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.patch 'http://testserver/v1/customer/{customer__external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.patch('http://testserver/v1/customer/{customer__external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer/{customer__external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "http://testserver/v1/customer/{customer__external_id}/", data)
    req.Header = headers

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

PATCH /customer/{customer__external_id}/

Body parameter

{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}

Parameters

Name In Type Required Description
body body CustomerData true none
customer__external_id path string true none

Example responses

200 Response

{
  "required": [
    "first_names",
    "last_name",
    "pesel_number",
    "id_valid_until",
    "card_valid_until",
    "card_number",
    "card_owner"
  ],
  "type": "object",
  "properties": {
    "first_names": {
      "title": "First names",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "last_name": {
      "title": "Last name",
      "type": "string",
      "maxLength": 128,
      "minLength": 1
    },
    "pesel_number": {
      "title": "Pesel number",
      "type": "string",
      "maxLength": 11,
      "minLength": 1
    },
    "id_valid_until": {
      "title": "Id valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_valid_until": {
      "title": "Card valid until",
      "type": "string",
      "format": "date-time"
    },
    "card_number": {
      "title": "Card number",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "card_owner": {
      "title": "Card owner",
      "type": "string",
      "maxLength": 256,
      "minLength": 1
    },
    "customer": {
      "title": "Customer",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "address": {
      "title": "Address",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "city": {
      "title": "City",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "zip": {
      "title": "Zip",
      "type": "string",
      "maxLength": 11,
      "nullable": true
    },
    "email": {
      "title": "Email",
      "type": "string",
      "maxLength": 128,
      "nullable": true
    },
    "phone": {
      "title": "Phone",
      "type": "string",
      "maxLength": 12,
      "nullable": true
    },
    "payday_loan_count": {
      "title": "Payday loan count",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK CustomerData

customer_order_token_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/customer/{external_id}/order_token/ \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/customer/{external_id}/order_token/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer/{external_id}/order_token/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer/{external_id}/order_token/',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/customer/{external_id}/order_token/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.post('http://testserver/v1/customer/{external_id}/order_token/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer/{external_id}/order_token/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/customer/{external_id}/order_token/", data)
    req.Header = headers

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

POST /customer/{external_id}/order_token/

Parameters

Name In Type Required Description
external_id path string true none

Responses

Status Meaning Description Schema
201 Created Created None

customer_data

customer_data_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/customer_data/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/customer_data/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer_data/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "pin"
  ],
  "type": "object",
  "properties": {
    "pin": {
      "title": "Pin",
      "type": "string",
      "maxLength": 4,
      "minLength": 1
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer_data/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/customer_data/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/customer_data/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer_data/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/customer_data/", data)
    req.Header = headers

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

POST /customer_data/

Body parameter

{
  "required": [
    "pin"
  ],
  "type": "object",
  "properties": {
    "pin": {
      "title": "Pin",
      "type": "string",
      "maxLength": 4,
      "minLength": 1
    }
  }
}

Parameters

Name In Type Required Description
body body CustomerDataAuth true none

Example responses

201 Response

{
  "required": [
    "pin"
  ],
  "type": "object",
  "properties": {
    "pin": {
      "title": "Pin",
      "type": "string",
      "maxLength": 4,
      "minLength": 1
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created CustomerDataAuth

customer_order

customer_order_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/customer_order/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/customer_order/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer_order/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer_order/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/customer_order/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/customer_order/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer_order/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/customer_order/", data)
    req.Header = headers

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

GET /customer_order/

Parameters

Name In Type Required Description
key query string false none

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "key",
      "customer",
      "order"
    ],
    "type": "object",
    "properties": {
      "key": {
        "title": "Key",
        "type": "string",
        "maxLength": 20,
        "minLength": 1
      },
      "customer": {
        "required": [
          "first_names",
          "last_name",
          "pesel_number",
          "id_valid_until",
          "card_valid_until",
          "card_number",
          "card_owner"
        ],
        "type": "object",
        "properties": {
          "first_names": {
            "title": "First names",
            "type": "string",
            "maxLength": 128,
            "minLength": 1
          },
          "last_name": {
            "title": "Last name",
            "type": "string",
            "maxLength": 128,
            "minLength": 1
          },
          "pesel_number": {
            "title": "Pesel number",
            "type": "string",
            "maxLength": 11,
            "minLength": 1
          },
          "id_valid_until": {
            "title": "Id valid until",
            "type": "string",
            "format": "date-time"
          },
          "card_valid_until": {
            "title": "Card valid until",
            "type": "string",
            "format": "date-time"
          },
          "card_number": {
            "title": "Card number",
            "type": "string",
            "maxLength": 20,
            "minLength": 1
          },
          "card_owner": {
            "title": "Card owner",
            "type": "string",
            "maxLength": 256,
            "minLength": 1
          },
          "customer": {
            "title": "Customer",
            "type": "string",
            "format": "uuid",
            "readOnly": true
          },
          "address": {
            "title": "Address",
            "type": "string",
            "maxLength": 128,
            "nullable": true
          },
          "city": {
            "title": "City",
            "type": "string",
            "maxLength": 128,
            "nullable": true
          },
          "zip": {
            "title": "Zip",
            "type": "string",
            "maxLength": 11,
            "nullable": true
          },
          "email": {
            "title": "Email",
            "type": "string",
            "maxLength": 128,
            "nullable": true
          },
          "phone": {
            "title": "Phone",
            "type": "string",
            "maxLength": 12,
            "nullable": true
          },
          "payday_loan_count": {
            "title": "Payday loan count",
            "type": "string",
            "readOnly": true
          }
        }
      },
      "order": {
        "title": "Order",
        "required": [
          "id",
          "user",
          "notional"
        ],
        "type": "object",
        "properties": {
          "id": {
            "title": "Id",
            "type": "string",
            "format": "uuid"
          },
          "user": {
            "title": "User",
            "type": "integer"
          },
          "product": {
            "title": "Product",
            "required": [
              "risk_attributes",
              "name",
              "description"
            ],
            "type": "object",
            "properties": {
              "id": {
                "title": "ID",
                "type": "integer",
                "readOnly": true
              },
              "risk_attributes": {
                "title": "Risk attributes",
                "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
                "type": "string",
                "minLength": 1
              },
              "cash_flow_schedule": {
                "title": "Cash flow schedule",
                "type": "string",
                "nullable": true
              },
              "events_of_default": {
                "title": "Events of default",
                "type": "string",
                "nullable": true
              },
              "name": {
                "title": "Name",
                "type": "string",
                "maxLength": 45,
                "minLength": 1
              },
              "description": {
                "title": "Description",
                "type": "string",
                "maxLength": 200,
                "minLength": 1
              },
              "duration": {
                "title": "Duration",
                "type": "integer",
                "maximum": 2147483647,
                "minimum": -2147483648
              },
              "category": {
                "title": "Category",
                "type": "integer",
                "enum": [
                  0,
                  1,
                  2
                ]
              },
              "auction_duration": {
                "title": "Auction duration",
                "type": "number"
              }
            }
          },
          "created": {
            "title": "Created",
            "type": "string",
            "format": "date-time",
            "readOnly": true
          },
          "status": {
            "title": "Status",
            "type": "string",
            "readOnly": true
          },
          "notional": {
            "title": "Notional",
            "type": "string",
            "format": "decimal"
          },
          "auction_id": {
            "title": "Auction id",
            "type": "string",
            "readOnly": true
          }
        }
      },
      "valid_from": {
        "title": "Valid from",
        "type": "string",
        "readOnly": true
      },
      "valid_till": {
        "title": "Valid till",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [KeyCustomerMapping] false none none
» key string true none none
» customer CustomerData true none none
»» first_names string true none none
»» last_name string true none none
»» pesel_number string true none none
»» id_valid_until string(date-time) true none none
»» card_valid_until string(date-time) true none none
»» card_number string true none none
»» card_owner string true none none
»» customer string(uuid) false read-only none
»» address string\ null false none
»» city string\ null false none
»» zip string\ null false none
»» email string\ null false none
»» phone string\ null false none
»» payday_loan_count string false read-only none
» order Order true none none
»» id string(uuid) true none none
»» user integer true none none
»» product Product false none none
»»» id integer false read-only none
»»» risk_attributes string true none It has to be JSON according to the following schema: {"type": "array", "items": {"type": "object", "properties": {"key": {"type": "string"}, "mandatory": {"type": "boolean"}, "type": {"enum": ["number", "string", "array"]}, "array_for_select": {"type": "array"}, "personal": {"type": "boolean"}, "source": {"enum": ["DSP", "customer"]}, "label": {"type": "string"}}, "if": {"properties": {"type": {"enum": ["array"]}}}, "then": {"required": ["key", "mandatory", "type", "array_for_select", "personal", "source", "label"], "properties": {"array_for_select": {"type": "array", "minItems": 1}}}, "else": {"required": ["key", "mandatory", "type", "personal", "source", "label"]}}}
»»» cash_flow_schedule string\ null false none
»»» events_of_default string\ null false none
»»» name string true none none
»»» description string true none none
»»» duration integer false none none
»»» category integer false none none
»»» auction_duration number false none none
»» created string(date-time) false read-only none
»» status string false read-only none
»» notional string(decimal) true none none
»» auction_id string false read-only none
» valid_from string false read-only none
» valid_till string false read-only none

Enumerated Values

Property Value
category 0
category 1
category 2

customer_order_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/customer_order/{key}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/customer_order/{key}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/customer_order/{key}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/customer_order/{key}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/customer_order/{key}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/customer_order/{key}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/customer_order/{key}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/customer_order/{key}/", data)
    req.Header = headers

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

GET /customer_order/{key}/

Parameters

Name In Type Required Description
key path string true none

Example responses

200 Response

{
  "required": [
    "key",
    "customer",
    "order"
  ],
  "type": "object",
  "properties": {
    "key": {
      "title": "Key",
      "type": "string",
      "maxLength": 20,
      "minLength": 1
    },
    "customer": {
      "required": [
        "first_names",
        "last_name",
        "pesel_number",
        "id_valid_until",
        "card_valid_until",
        "card_number",
        "card_owner"
      ],
      "type": "object",
      "properties": {
        "first_names": {
          "title": "First names",
          "type": "string",
          "maxLength": 128,
          "minLength": 1
        },
        "last_name": {
          "title": "Last name",
          "type": "string",
          "maxLength": 128,
          "minLength": 1
        },
        "pesel_number": {
          "title": "Pesel number",
          "type": "string",
          "maxLength": 11,
          "minLength": 1
        },
        "id_valid_until": {
          "title": "Id valid until",
          "type": "string",
          "format": "date-time"
        },
        "card_valid_until": {
          "title": "Card valid until",
          "type": "string",
          "format": "date-time"
        },
        "card_number": {
          "title": "Card number",
          "type": "string",
          "maxLength": 20,
          "minLength": 1
        },
        "card_owner": {
          "title": "Card owner",
          "type": "string",
          "maxLength": 256,
          "minLength": 1
        },
        "customer": {
          "title": "Customer",
          "type": "string",
          "format": "uuid",
          "readOnly": true
        },
        "address": {
          "title": "Address",
          "type": "string",
          "maxLength": 128,
          "nullable": true
        },
        "city": {
          "title": "City",
          "type": "string",
          "maxLength": 128,
          "nullable": true
        },
        "zip": {
          "title": "Zip",
          "type": "string",
          "maxLength": 11,
          "nullable": true
        },
        "email": {
          "title": "Email",
          "type": "string",
          "maxLength": 128,
          "nullable": true
        },
        "phone": {
          "title": "Phone",
          "type": "string",
          "maxLength": 12,
          "nullable": true
        },
        "payday_loan_count": {
          "title": "Payday loan count",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "order": {
      "title": "Order",
      "required": [
        "id",
        "user",
        "notional"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "Id",
          "type": "string",
          "format": "uuid"
        },
        "user": {
          "title": "User",
          "type": "integer"
        },
        "product": {
          "title": "Product",
          "required": [
            "risk_attributes",
            "name",
            "description"
          ],
          "type": "object",
          "properties": {
            "id": {
              "title": "ID",
              "type": "integer",
              "readOnly": true
            },
            "risk_attributes": {
              "title": "Risk attributes",
              "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
              "type": "string",
              "minLength": 1
            },
            "cash_flow_schedule": {
              "title": "Cash flow schedule",
              "type": "string",
              "nullable": true
            },
            "events_of_default": {
              "title": "Events of default",
              "type": "string",
              "nullable": true
            },
            "name": {
              "title": "Name",
              "type": "string",
              "maxLength": 45,
              "minLength": 1
            },
            "description": {
              "title": "Description",
              "type": "string",
              "maxLength": 200,
              "minLength": 1
            },
            "duration": {
              "title": "Duration",
              "type": "integer",
              "maximum": 2147483647,
              "minimum": -2147483648
            },
            "category": {
              "title": "Category",
              "type": "integer",
              "enum": [
                0,
                1,
                2
              ]
            },
            "auction_duration": {
              "title": "Auction duration",
              "type": "number"
            }
          }
        },
        "created": {
          "title": "Created",
          "type": "string",
          "format": "date-time",
          "readOnly": true
        },
        "status": {
          "title": "Status",
          "type": "string",
          "readOnly": true
        },
        "notional": {
          "title": "Notional",
          "type": "string",
          "format": "decimal"
        },
        "auction_id": {
          "title": "Auction id",
          "type": "string",
          "readOnly": true
        }
      }
    },
    "valid_from": {
      "title": "Valid from",
      "type": "string",
      "readOnly": true
    },
    "valid_till": {
      "title": "Valid till",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK KeyCustomerMapping

geography

geography_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/geography \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/geography HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/geography',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/geography',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/geography',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/geography', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/geography");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/geography", data)
    req.Header = headers

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

GET /geography

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "status"
    ],
    "type": "object",
    "properties": {
      "country": {
        "title": "Country",
        "type": "string",
        "maxLength": 56,
        "minLength": 1
      },
      "continent_name": {
        "title": "Continent name",
        "type": "string",
        "readOnly": true
      },
      "status": {
        "title": "Status",
        "type": "string"
      },
      "id": {
        "title": "ID",
        "type": "integer",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Geography] false none none
» country string false none none
» continent_name string false read-only none
» status string true none none
» id integer false read-only none

notification

notification_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/notification/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/notification/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/notification/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/notification/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/notification/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/notification/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/notification/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/notification/", data)
    req.Header = headers

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

GET /notification/

Parameters

Name In Type Required Description
ordering query string false Which field to use when ordering the results.

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "message",
      "url"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "ID",
        "type": "integer",
        "readOnly": true
      },
      "code": {
        "title": "Code",
        "type": "string",
        "readOnly": true
      },
      "message": {
        "title": "Message",
        "type": "string",
        "maxLength": 100,
        "minLength": 1
      },
      "url": {
        "title": "Url",
        "type": "string",
        "maxLength": 90,
        "minLength": 1
      },
      "category": {
        "title": "Category",
        "type": "string",
        "readOnly": true
      },
      "valid_until": {
        "title": "Valid until",
        "type": "string",
        "format": "date-time",
        "nullable": true
      },
      "created": {
        "title": "Created",
        "type": "string",
        "format": "date-time",
        "readOnly": true
      },
      "unread": {
        "title": "Unread",
        "type": "boolean"
      },
      "object_id": {
        "title": "Object id",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Notification] false none none
» id integer false read-only none
» code string false read-only none
» message string true none none
» url string true none none
» category string false read-only none
» valid_until string(date-time)\ null false none
» created string(date-time) false read-only none
» unread boolean false none none
» object_id string false read-only none

notification_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/notification/{id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/notification/{id}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/notification/{id}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/notification/{id}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/notification/{id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/notification/{id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/notification/{id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/notification/{id}/", data)
    req.Header = headers

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

GET /notification/{id}/

Parameters

Name In Type Required Description
id path integer true A unique integer value identifying this notification.

Example responses

200 Response

{
  "required": [
    "message",
    "url"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "ID",
      "type": "integer",
      "readOnly": true
    },
    "code": {
      "title": "Code",
      "type": "string",
      "readOnly": true
    },
    "message": {
      "title": "Message",
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "url": {
      "title": "Url",
      "type": "string",
      "maxLength": 90,
      "minLength": 1
    },
    "category": {
      "title": "Category",
      "type": "string",
      "readOnly": true
    },
    "valid_until": {
      "title": "Valid until",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "unread": {
      "title": "Unread",
      "type": "boolean"
    },
    "object_id": {
      "title": "Object id",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Notification

notification_mark_as_read

Code samples

# You can also use wget
curl -X POST http://testserver/v1/notification/{id}/mark_as_read/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/notification/{id}/mark_as_read/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/notification/{id}/mark_as_read/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "message",
    "url"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "ID",
      "type": "integer",
      "readOnly": true
    },
    "code": {
      "title": "Code",
      "type": "string",
      "readOnly": true
    },
    "message": {
      "title": "Message",
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "url": {
      "title": "Url",
      "type": "string",
      "maxLength": 90,
      "minLength": 1
    },
    "category": {
      "title": "Category",
      "type": "string",
      "readOnly": true
    },
    "valid_until": {
      "title": "Valid until",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "unread": {
      "title": "Unread",
      "type": "boolean"
    },
    "object_id": {
      "title": "Object id",
      "type": "string",
      "readOnly": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/notification/{id}/mark_as_read/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/notification/{id}/mark_as_read/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/notification/{id}/mark_as_read/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/notification/{id}/mark_as_read/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/notification/{id}/mark_as_read/", data)
    req.Header = headers

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

POST /notification/{id}/mark_as_read/

Body parameter

{
  "required": [
    "message",
    "url"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "ID",
      "type": "integer",
      "readOnly": true
    },
    "code": {
      "title": "Code",
      "type": "string",
      "readOnly": true
    },
    "message": {
      "title": "Message",
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "url": {
      "title": "Url",
      "type": "string",
      "maxLength": 90,
      "minLength": 1
    },
    "category": {
      "title": "Category",
      "type": "string",
      "readOnly": true
    },
    "valid_until": {
      "title": "Valid until",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "unread": {
      "title": "Unread",
      "type": "boolean"
    },
    "object_id": {
      "title": "Object id",
      "type": "string",
      "readOnly": true
    }
  }
}

Parameters

Name In Type Required Description
body body Notification true none
id path integer true A unique integer value identifying this notification.

Example responses

201 Response

{
  "required": [
    "message",
    "url"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "ID",
      "type": "integer",
      "readOnly": true
    },
    "code": {
      "title": "Code",
      "type": "string",
      "readOnly": true
    },
    "message": {
      "title": "Message",
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "url": {
      "title": "Url",
      "type": "string",
      "maxLength": 90,
      "minLength": 1
    },
    "category": {
      "title": "Category",
      "type": "string",
      "readOnly": true
    },
    "valid_until": {
      "title": "Valid until",
      "type": "string",
      "format": "date-time",
      "nullable": true
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "unread": {
      "title": "Unread",
      "type": "boolean"
    },
    "object_id": {
      "title": "Object id",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created Notification

order

order_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/order/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/order/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/order/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/order/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/order/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/order/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/order/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/order/", data)
    req.Header = headers

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

GET /order/

Parameters

Name In Type Required Description
ordering query string false Which field to use when ordering the results.

Example responses

200 Response

{
  "type": "array",
  "items": {
    "title": "Order",
    "required": [
      "id",
      "user",
      "notional"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "Id",
        "type": "string",
        "format": "uuid"
      },
      "user": {
        "title": "User",
        "type": "integer"
      },
      "product": {
        "title": "Product",
        "required": [
          "risk_attributes",
          "name",
          "description"
        ],
        "type": "object",
        "properties": {
          "id": {
            "title": "ID",
            "type": "integer",
            "readOnly": true
          },
          "risk_attributes": {
            "title": "Risk attributes",
            "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
            "type": "string",
            "minLength": 1
          },
          "cash_flow_schedule": {
            "title": "Cash flow schedule",
            "type": "string",
            "nullable": true
          },
          "events_of_default": {
            "title": "Events of default",
            "type": "string",
            "nullable": true
          },
          "name": {
            "title": "Name",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "description": {
            "title": "Description",
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "duration": {
            "title": "Duration",
            "type": "integer",
            "maximum": 2147483647,
            "minimum": -2147483648
          },
          "category": {
            "title": "Category",
            "type": "integer",
            "enum": [
              0,
              1,
              2
            ]
          },
          "auction_duration": {
            "title": "Auction duration",
            "type": "number"
          }
        }
      },
      "created": {
        "title": "Created",
        "type": "string",
        "format": "date-time",
        "readOnly": true
      },
      "status": {
        "title": "Status",
        "type": "string",
        "readOnly": true
      },
      "notional": {
        "title": "Notional",
        "type": "string",
        "format": "decimal"
      },
      "auction_id": {
        "title": "Auction id",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Order] false none none
» Order Order false none none
»» id string(uuid) true none none
»» user integer true none none
»» product Product false none none
»»» id integer false read-only none
»»» risk_attributes string true none It has to be JSON according to the following schema: {"type": "array", "items": {"type": "object", "properties": {"key": {"type": "string"}, "mandatory": {"type": "boolean"}, "type": {"enum": ["number", "string", "array"]}, "array_for_select": {"type": "array"}, "personal": {"type": "boolean"}, "source": {"enum": ["DSP", "customer"]}, "label": {"type": "string"}}, "if": {"properties": {"type": {"enum": ["array"]}}}, "then": {"required": ["key", "mandatory", "type", "array_for_select", "personal", "source", "label"], "properties": {"array_for_select": {"type": "array", "minItems": 1}}}, "else": {"required": ["key", "mandatory", "type", "personal", "source", "label"]}}}
»»» cash_flow_schedule string\ null false none
»»» events_of_default string\ null false none
»»» name string true none none
»»» description string true none none
»»» duration integer false none none
»»» category integer false none none
»»» auction_duration number false none none
»» created string(date-time) false read-only none
»» status string false read-only none
»» notional string(decimal) true none none
»» auction_id string false read-only none

Enumerated Values

Property Value
category 0
category 1
category 2

order_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/order/ \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/order/ HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/order/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "title": "Order",
  "required": [
    "id",
    "user",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "user": {
      "title": "User",
      "type": "integer"
    },
    "product": {
      "title": "Product",
      "required": [
        "risk_attributes",
        "name",
        "description"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "ID",
          "type": "integer",
          "readOnly": true
        },
        "risk_attributes": {
          "title": "Risk attributes",
          "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
          "type": "string",
          "minLength": 1
        },
        "cash_flow_schedule": {
          "title": "Cash flow schedule",
          "type": "string",
          "nullable": true
        },
        "events_of_default": {
          "title": "Events of default",
          "type": "string",
          "nullable": true
        },
        "name": {
          "title": "Name",
          "type": "string",
          "maxLength": 45,
          "minLength": 1
        },
        "description": {
          "title": "Description",
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "duration": {
          "title": "Duration",
          "type": "integer",
          "maximum": 2147483647,
          "minimum": -2147483648
        },
        "category": {
          "title": "Category",
          "type": "integer",
          "enum": [
            0,
            1,
            2
          ]
        },
        "auction_duration": {
          "title": "Auction duration",
          "type": "number"
        }
      }
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "auction_id": {
      "title": "Auction id",
      "type": "string",
      "readOnly": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/order/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/order/',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('http://testserver/v1/order/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/order/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/order/", data)
    req.Header = headers

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

POST /order/

Body parameter

{
  "title": "Order",
  "required": [
    "id",
    "user",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "user": {
      "title": "User",
      "type": "integer"
    },
    "product": {
      "title": "Product",
      "required": [
        "risk_attributes",
        "name",
        "description"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "ID",
          "type": "integer",
          "readOnly": true
        },
        "risk_attributes": {
          "title": "Risk attributes",
          "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
          "type": "string",
          "minLength": 1
        },
        "cash_flow_schedule": {
          "title": "Cash flow schedule",
          "type": "string",
          "nullable": true
        },
        "events_of_default": {
          "title": "Events of default",
          "type": "string",
          "nullable": true
        },
        "name": {
          "title": "Name",
          "type": "string",
          "maxLength": 45,
          "minLength": 1
        },
        "description": {
          "title": "Description",
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "duration": {
          "title": "Duration",
          "type": "integer",
          "maximum": 2147483647,
          "minimum": -2147483648
        },
        "category": {
          "title": "Category",
          "type": "integer",
          "enum": [
            0,
            1,
            2
          ]
        },
        "auction_duration": {
          "title": "Auction duration",
          "type": "number"
        }
      }
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "auction_id": {
      "title": "Auction id",
      "type": "string",
      "readOnly": true
    }
  }
}

Parameters

Name In Type Required Description
body body Order true none

Example responses

201 Response

{
  "title": "Order",
  "required": [
    "id",
    "user",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "user": {
      "title": "User",
      "type": "integer"
    },
    "product": {
      "title": "Product",
      "required": [
        "risk_attributes",
        "name",
        "description"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "ID",
          "type": "integer",
          "readOnly": true
        },
        "risk_attributes": {
          "title": "Risk attributes",
          "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
          "type": "string",
          "minLength": 1
        },
        "cash_flow_schedule": {
          "title": "Cash flow schedule",
          "type": "string",
          "nullable": true
        },
        "events_of_default": {
          "title": "Events of default",
          "type": "string",
          "nullable": true
        },
        "name": {
          "title": "Name",
          "type": "string",
          "maxLength": 45,
          "minLength": 1
        },
        "description": {
          "title": "Description",
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "duration": {
          "title": "Duration",
          "type": "integer",
          "maximum": 2147483647,
          "minimum": -2147483648
        },
        "category": {
          "title": "Category",
          "type": "integer",
          "enum": [
            0,
            1,
            2
          ]
        },
        "auction_duration": {
          "title": "Auction duration",
          "type": "number"
        }
      }
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "auction_id": {
      "title": "Auction id",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
201 Created Created Order

order_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/order/{external_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/order/{external_id}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/order/{external_id}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/order/{external_id}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/order/{external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/order/{external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/order/{external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/order/{external_id}/", data)
    req.Header = headers

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

GET /order/{external_id}/

Parameters

Name In Type Required Description
external_id path string(uuid) true none

Example responses

200 Response

{
  "title": "Order",
  "required": [
    "id",
    "user",
    "notional"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "user": {
      "title": "User",
      "type": "integer"
    },
    "product": {
      "title": "Product",
      "required": [
        "risk_attributes",
        "name",
        "description"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "ID",
          "type": "integer",
          "readOnly": true
        },
        "risk_attributes": {
          "title": "Risk attributes",
          "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
          "type": "string",
          "minLength": 1
        },
        "cash_flow_schedule": {
          "title": "Cash flow schedule",
          "type": "string",
          "nullable": true
        },
        "events_of_default": {
          "title": "Events of default",
          "type": "string",
          "nullable": true
        },
        "name": {
          "title": "Name",
          "type": "string",
          "maxLength": 45,
          "minLength": 1
        },
        "description": {
          "title": "Description",
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "duration": {
          "title": "Duration",
          "type": "integer",
          "maximum": 2147483647,
          "minimum": -2147483648
        },
        "category": {
          "title": "Category",
          "type": "integer",
          "enum": [
            0,
            1,
            2
          ]
        },
        "auction_duration": {
          "title": "Auction duration",
          "type": "number"
        }
      }
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "auction_id": {
      "title": "Auction id",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Order

payday_order

payday_order_create

Code samples

# You can also use wget
curl -X POST http://testserver/v1/payday_order/{order_token}/ \
  -H 'Authorization: API_KEY'

POST http://testserver/v1/payday_order/{order_token}/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/payday_order/{order_token}/',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/payday_order/{order_token}/',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.post 'http://testserver/v1/payday_order/{order_token}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.post('http://testserver/v1/payday_order/{order_token}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/payday_order/{order_token}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "http://testserver/v1/payday_order/{order_token}/", data)
    req.Header = headers

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

POST /payday_order/{order_token}/

Parameters

Name In Type Required Description
order_token path string true none

Responses

Status Meaning Description Schema
201 Created Created None

product

product_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/product/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/product/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/product/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/product/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/product/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/product/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/product/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/product/", data)
    req.Header = headers

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

GET /product/

Parameters

Name In Type Required Description
category query string false none

Example responses

200 Response

{
  "type": "array",
  "items": {
    "title": "Product",
    "required": [
      "risk_attributes",
      "name",
      "description"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "ID",
        "type": "integer",
        "readOnly": true
      },
      "risk_attributes": {
        "title": "Risk attributes",
        "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
        "type": "string",
        "minLength": 1
      },
      "cash_flow_schedule": {
        "title": "Cash flow schedule",
        "type": "string",
        "nullable": true
      },
      "events_of_default": {
        "title": "Events of default",
        "type": "string",
        "nullable": true
      },
      "name": {
        "title": "Name",
        "type": "string",
        "maxLength": 45,
        "minLength": 1
      },
      "description": {
        "title": "Description",
        "type": "string",
        "maxLength": 200,
        "minLength": 1
      },
      "duration": {
        "title": "Duration",
        "type": "integer",
        "maximum": 2147483647,
        "minimum": -2147483648
      },
      "category": {
        "title": "Category",
        "type": "integer",
        "enum": [
          0,
          1,
          2
        ]
      },
      "auction_duration": {
        "title": "Auction duration",
        "type": "number"
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Product] false none none
» Product Product false none none
»» id integer false read-only none
»» risk_attributes string true none It has to be JSON according to the following schema: {"type": "array", "items": {"type": "object", "properties": {"key": {"type": "string"}, "mandatory": {"type": "boolean"}, "type": {"enum": ["number", "string", "array"]}, "array_for_select": {"type": "array"}, "personal": {"type": "boolean"}, "source": {"enum": ["DSP", "customer"]}, "label": {"type": "string"}}, "if": {"properties": {"type": {"enum": ["array"]}}}, "then": {"required": ["key", "mandatory", "type", "array_for_select", "personal", "source", "label"], "properties": {"array_for_select": {"type": "array", "minItems": 1}}}, "else": {"required": ["key", "mandatory", "type", "personal", "source", "label"]}}}
»» cash_flow_schedule string\ null false none
»» events_of_default string\ null false none
»» name string true none none
»» description string true none none
»» duration integer false none none
»» category integer false none none
»» auction_duration number false none none

Enumerated Values

Property Value
category 0
category 1
category 2

risk_ratings

risk_ratings_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/risk_ratings \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/risk_ratings HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/risk_ratings',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/risk_ratings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/risk_ratings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/risk_ratings', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/risk_ratings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/risk_ratings", data)
    req.Header = headers

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

GET /risk_ratings

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "category"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "ID",
        "type": "integer",
        "readOnly": true
      },
      "category": {
        "title": "Category",
        "type": "string",
        "maxLength": 3,
        "minLength": 1
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [RiskRating] false none none
» id integer false read-only none
» category string true none none

schema

schema_dsp_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/schema/dsp/ \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/schema/dsp/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/schema/dsp/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/schema/dsp/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/schema/dsp/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/schema/dsp/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/schema/dsp/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/schema/dsp/", data)
    req.Header = headers

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

GET /schema/dsp/

Responses

Status Meaning Description Schema
200 OK OK None

schema_dsp_ssp_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/schema/dsp_ssp/ \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/schema/dsp_ssp/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/schema/dsp_ssp/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/schema/dsp_ssp/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/schema/dsp_ssp/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/schema/dsp_ssp/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/schema/dsp_ssp/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/schema/dsp_ssp/", data)
    req.Header = headers

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

GET /schema/dsp_ssp/

Responses

Status Meaning Description Schema
200 OK OK None

schema_ssp_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/schema/ssp/ \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/schema/ssp/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/schema/ssp/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/schema/ssp/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/schema/ssp/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/schema/ssp/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/schema/ssp/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/schema/ssp/", data)
    req.Header = headers

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

GET /schema/ssp/

Responses

Status Meaning Description Schema
200 OK OK None

schema_unauthorized_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/schema/unauthorized/ \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/schema/unauthorized/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/schema/unauthorized/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/schema/unauthorized/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/schema/unauthorized/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/schema/unauthorized/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/schema/unauthorized/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/schema/unauthorized/", data)
    req.Header = headers

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

GET /schema/unauthorized/

Responses

Status Meaning Description Schema
200 OK OK None

stats

stats_version_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/stats/version/ \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/stats/version/ HTTP/1.1
Host: testserver

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/stats/version/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/stats/version/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/stats/version/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/stats/version/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/stats/version/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/stats/version/", data)
    req.Header = headers

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

GET /stats/version/

Returns sym-poc backend version.

Responses

Status Meaning Description Schema
200 OK OK None

transaction

transaction_list

Code samples

# You can also use wget
curl -X GET http://testserver/v1/transaction/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/transaction/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/transaction/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/transaction/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/transaction/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/transaction/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/transaction/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/transaction/", data)
    req.Header = headers

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

GET /transaction/

Parameters

Name In Type Required Description
status query string false none
auction__external_id query string false none
created query string false none
auction__order query string false none
auction_order_prod_cust_attr query string false none
ordering query string false Which field to use when ordering the results.

Example responses

200 Response

{
  "type": "array",
  "items": {
    "required": [
      "id",
      "notional",
      "product",
      "payment_history"
    ],
    "type": "object",
    "properties": {
      "id": {
        "title": "Id",
        "type": "string",
        "format": "uuid"
      },
      "auction": {
        "title": "Auction",
        "type": "string",
        "format": "uuid",
        "readOnly": true
      },
      "status": {
        "title": "Status",
        "type": "string",
        "readOnly": true
      },
      "notional": {
        "title": "Notional",
        "type": "string",
        "format": "decimal"
      },
      "created": {
        "title": "Created",
        "type": "string",
        "format": "date-time",
        "readOnly": true
      },
      "product": {
        "title": "Product",
        "required": [
          "risk_attributes",
          "name",
          "description"
        ],
        "type": "object",
        "properties": {
          "id": {
            "title": "ID",
            "type": "integer",
            "readOnly": true
          },
          "risk_attributes": {
            "title": "Risk attributes",
            "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
            "type": "string",
            "minLength": 1
          },
          "cash_flow_schedule": {
            "title": "Cash flow schedule",
            "type": "string",
            "nullable": true
          },
          "events_of_default": {
            "title": "Events of default",
            "type": "string",
            "nullable": true
          },
          "name": {
            "title": "Name",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "description": {
            "title": "Description",
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "duration": {
            "title": "Duration",
            "type": "integer",
            "maximum": 2147483647,
            "minimum": -2147483648
          },
          "category": {
            "title": "Category",
            "type": "integer",
            "enum": [
              0,
              1,
              2
            ]
          },
          "auction_duration": {
            "title": "Auction duration",
            "type": "number"
          }
        }
      },
      "payment_history": {
        "type": "array",
        "items": {
          "required": [
            "due_date",
            "value",
            "status"
          ],
          "type": "object",
          "properties": {
            "due_date": {
              "title": "Due date",
              "type": "string",
              "format": "date"
            },
            "payment_date": {
              "title": "Payment date",
              "type": "string",
              "format": "date",
              "nullable": true
            },
            "value": {
              "title": "Value",
              "type": "number"
            },
            "status": {
              "title": "Status",
              "type": "string",
              "minLength": 1
            }
          }
        }
      },
      "payment_schedule": {
        "title": "Payment schedule",
        "type": "string",
        "readOnly": true
      },
      "price": {
        "title": "Price",
        "type": "string",
        "readOnly": true
      },
      "pv": {
        "title": "Pv",
        "type": "string",
        "readOnly": true
      },
      "duration": {
        "title": "Duration",
        "type": "string",
        "readOnly": true
      },
      "ssp_username": {
        "title": "Ssp username",
        "type": "string",
        "readOnly": true
      }
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Transaction] false none none
» id string(uuid) true none none
» auction string(uuid) false read-only none
» status string false read-only none
» notional string(decimal) true none none
» created string(date-time) false read-only none
» product Product true none none
»» id integer false read-only none
»» risk_attributes string true none It has to be JSON according to the following schema: {"type": "array", "items": {"type": "object", "properties": {"key": {"type": "string"}, "mandatory": {"type": "boolean"}, "type": {"enum": ["number", "string", "array"]}, "array_for_select": {"type": "array"}, "personal": {"type": "boolean"}, "source": {"enum": ["DSP", "customer"]}, "label": {"type": "string"}}, "if": {"properties": {"type": {"enum": ["array"]}}}, "then": {"required": ["key", "mandatory", "type", "array_for_select", "personal", "source", "label"], "properties": {"array_for_select": {"type": "array", "minItems": 1}}}, "else": {"required": ["key", "mandatory", "type", "personal", "source", "label"]}}}
»» cash_flow_schedule string\ null false none
»» events_of_default string\ null false none
»» name string true none none
»» description string true none none
»» duration integer false none none
»» category integer false none none
»» auction_duration number false none none
» payment_history [Payment] true none none
»» due_date string(date) true none none
»» payment_date string(date)\ null false none
»» value number true none none
»» status string true none none
» payment_schedule string false read-only none
» price string false read-only none
» pv string false read-only none
» duration string false read-only none
» ssp_username string false read-only none

Enumerated Values

Property Value
category 0
category 1
category 2

transaction_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/transaction/{external_id}/ \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/transaction/{external_id}/ HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/transaction/{external_id}/',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/transaction/{external_id}/',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/transaction/{external_id}/',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/transaction/{external_id}/', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/transaction/{external_id}/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/transaction/{external_id}/", data)
    req.Header = headers

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

GET /transaction/{external_id}/

Parameters

Name In Type Required Description
external_id path string(uuid) true none

Example responses

200 Response

{
  "required": [
    "id",
    "notional",
    "product",
    "payment_history"
  ],
  "type": "object",
  "properties": {
    "id": {
      "title": "Id",
      "type": "string",
      "format": "uuid"
    },
    "auction": {
      "title": "Auction",
      "type": "string",
      "format": "uuid",
      "readOnly": true
    },
    "status": {
      "title": "Status",
      "type": "string",
      "readOnly": true
    },
    "notional": {
      "title": "Notional",
      "type": "string",
      "format": "decimal"
    },
    "created": {
      "title": "Created",
      "type": "string",
      "format": "date-time",
      "readOnly": true
    },
    "product": {
      "title": "Product",
      "required": [
        "risk_attributes",
        "name",
        "description"
      ],
      "type": "object",
      "properties": {
        "id": {
          "title": "ID",
          "type": "integer",
          "readOnly": true
        },
        "risk_attributes": {
          "title": "Risk attributes",
          "description": "It has to be JSON according to the following schema: {\"type\": \"array\", \"items\": {\"type\": \"object\", \"properties\": {\"key\": {\"type\": \"string\"}, \"mandatory\": {\"type\": \"boolean\"}, \"type\": {\"enum\": [\"number\", \"string\", \"array\"]}, \"array_for_select\": {\"type\": \"array\"}, \"personal\": {\"type\": \"boolean\"}, \"source\": {\"enum\": [\"DSP\", \"customer\"]}, \"label\": {\"type\": \"string\"}}, \"if\": {\"properties\": {\"type\": {\"enum\": [\"array\"]}}}, \"then\": {\"required\": [\"key\", \"mandatory\", \"type\", \"array_for_select\", \"personal\", \"source\", \"label\"], \"properties\": {\"array_for_select\": {\"type\": \"array\", \"minItems\": 1}}}, \"else\": {\"required\": [\"key\", \"mandatory\", \"type\", \"personal\", \"source\", \"label\"]}}}",
          "type": "string",
          "minLength": 1
        },
        "cash_flow_schedule": {
          "title": "Cash flow schedule",
          "type": "string",
          "nullable": true
        },
        "events_of_default": {
          "title": "Events of default",
          "type": "string",
          "nullable": true
        },
        "name": {
          "title": "Name",
          "type": "string",
          "maxLength": 45,
          "minLength": 1
        },
        "description": {
          "title": "Description",
          "type": "string",
          "maxLength": 200,
          "minLength": 1
        },
        "duration": {
          "title": "Duration",
          "type": "integer",
          "maximum": 2147483647,
          "minimum": -2147483648
        },
        "category": {
          "title": "Category",
          "type": "integer",
          "enum": [
            0,
            1,
            2
          ]
        },
        "auction_duration": {
          "title": "Auction duration",
          "type": "number"
        }
      }
    },
    "payment_history": {
      "type": "array",
      "items": {
        "required": [
          "due_date",
          "value",
          "status"
        ],
        "type": "object",
        "properties": {
          "due_date": {
            "title": "Due date",
            "type": "string",
            "format": "date"
          },
          "payment_date": {
            "title": "Payment date",
            "type": "string",
            "format": "date",
            "nullable": true
          },
          "value": {
            "title": "Value",
            "type": "number"
          },
          "status": {
            "title": "Status",
            "type": "string",
            "minLength": 1
          }
        }
      }
    },
    "payment_schedule": {
      "title": "Payment schedule",
      "type": "string",
      "readOnly": true
    },
    "price": {
      "title": "Price",
      "type": "string",
      "readOnly": true
    },
    "pv": {
      "title": "Pv",
      "type": "string",
      "readOnly": true
    },
    "duration": {
      "title": "Duration",
      "type": "string",
      "readOnly": true
    },
    "ssp_username": {
      "title": "Ssp username",
      "type": "string",
      "readOnly": true
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK Transaction

user

user_read

Code samples

# You can also use wget
curl -X GET http://testserver/v1/user \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET http://testserver/v1/user HTTP/1.1
Host: testserver
Accept: application/json

var headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/user',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/user',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.get 'http://testserver/v1/user',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('http://testserver/v1/user', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/user");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "http://testserver/v1/user", data)
    req.Header = headers

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

GET /user

Example responses

200 Response

{
  "required": [
    "addresses"
  ],
  "type": "object",
  "properties": {
    "addresses": {
      "type": "array",
      "items": {
        "required": [
          "name",
          "address",
          "email",
          "phone"
        ],
        "type": "object",
        "properties": {
          "name": {
            "title": "Name",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "address": {
            "title": "Address",
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "email": {
            "title": "Email",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "phone": {
            "title": "Phone",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          }
        }
      }
    },
    "username": {
      "title": "Username",
      "type": "string",
      "readOnly": true,
      "minLength": 1
    },
    "first_name": {
      "title": "First name",
      "type": "string",
      "maxLength": 30
    },
    "api_key": {
      "title": "Api key",
      "type": "string",
      "maxLength": 45,
      "minLength": 1
    }
  }
}

Responses

Status Meaning Description Schema
200 OK OK User

user_update

Code samples

# You can also use wget
curl -X PUT http://testserver/v1/user \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT http://testserver/v1/user HTTP/1.1
Host: testserver
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'http://testserver/v1/user',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "required": [
    "addresses"
  ],
  "type": "object",
  "properties": {
    "addresses": {
      "type": "array",
      "items": {
        "required": [
          "name",
          "address",
          "email",
          "phone"
        ],
        "type": "object",
        "properties": {
          "name": {
            "title": "Name",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "address": {
            "title": "Address",
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "email": {
            "title": "Email",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "phone": {
            "title": "Phone",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          }
        }
      }
    },
    "username": {
      "title": "Username",
      "type": "string",
      "readOnly": true,
      "minLength": 1
    },
    "first_name": {
      "title": "First name",
      "type": "string",
      "maxLength": 30
    },
    "api_key": {
      "title": "Api key",
      "type": "string",
      "maxLength": 45,
      "minLength": 1
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('http://testserver/v1/user',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put 'http://testserver/v1/user',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('http://testserver/v1/user', params={

}, headers = headers)

print r.json()

URL obj = new URL("http://testserver/v1/user");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "http://testserver/v1/user", data)
    req.Header = headers

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

PUT /user

Body parameter

{
  "required": [
    "addresses"
  ],
  "type": "object",
  "properties": {
    "addresses": {
      "type": "array",
      "items": {
        "required": [
          "name",
          "address",
          "email",
          "phone"
        ],
        "type": "object",
        "properties": {
          "name": {
            "title": "Name",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "address": {
            "title": "Address",
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "email": {
            "title": "Email",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          },
          "phone": {
            "title": "Phone",
            "type": "string",
            "maxLength": 45,
            "minLength": 1
          }
        }
      }
    },
    "username": {
      "title": "Username",