Mothership v1.0.0

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

The official, public REST API for Mothership.

Base URLs:

• https://app.mothership.cloud/api

Authentication

• oAuth2 authentication.

app

An application is a logical container for relating specific configuration environments together.

app.getApps

Code samples

# You can also use wget
curl -X GET /api/apps \
  -H 'Accept: application/json'

GET /api/apps HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps',
{
  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'
}

result = RestClient.get '/api/apps',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/apps', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps");
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"},

    }

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

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

GET /apps

Example responses

200 Response

[
  {
    "name": "string",
    "slug": "string",
    "description": "string",
    "account": "string",
    "active": false,
    "createdAt": "2018-12-09T04:42:21Z",
    "createdBy": "string",
    "modifiedAt": "2018-12-09T04:42:21Z",
    "modifiedBy": "string",
    "id": "string"
  }
]

<?xml version="1.0" encoding="UTF-8" ?>
<name>string</name>
<slug>string</slug>
<description>string</description>
<account>string</account>
<active>false</active>
<createdAt>2018-12-09T04:42:21Z</createdAt>
<createdBy>string</createdBy>
<modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
<modifiedBy>string</modifiedBy>
<id>string</id>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[app]	false	none	none
» name	string	true	none	none
» slug	string	false	none	none
» description	string	false	none	none
» account	string	true	none	none
» active	boolean	false	none	none
» createdAt	string(date-time)	false	none	none
» createdBy	string	false	none	none
» modifiedAt	string(date-time)	false	none	none
» modifiedBy	string	false	none	none
» id	string	false	none	none

app.createApp

Code samples

# You can also use wget
curl -X POST /api/apps \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/apps HTTP/1.1

Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: '/api/apps',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('/api/apps',
{
  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'
}

result = RestClient.post '/api/apps',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/apps', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps");
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"},

    }

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

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

POST /apps

Body parameter

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

name: string
slug: string
description: string
account: string
active: false
createdAt: '2018-12-09T04:42:21Z'
createdBy: string
modifiedAt: '2018-12-09T04:42:21Z'
modifiedBy: string
id: string

<?xml version="1.0" encoding="UTF-8" ?>
<app>
  <name>string</name>
  <slug>string</slug>
  <description>string</description>
  <account>string</account>
  <active>false</active>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</app>

Parameters

Parameter	In	Type	Required	Description
body	body	app	true	none

Example responses

200 Response

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<app>
  <name>string</name>
  <slug>string</slug>
  <description>string</description>
  <account>string</account>
  <active>false</active>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</app>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	app

app.getApp

Code samples

# You can also use wget
curl -X GET /api/apps/{slug} \
  -H 'Accept: application/json'

GET /api/apps/{slug} HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps/{slug}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps/{slug}',
{
  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'
}

result = RestClient.get '/api/apps/{slug}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/apps/{slug}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}");
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"},

    }

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

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

GET /apps/{slug}

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none

Example responses

200 Response

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<app>
  <name>string</name>
  <slug>string</slug>
  <description>string</description>
  <account>string</account>
  <active>false</active>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</app>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	app

app.updateApp

Code samples

# You can also use wget
curl -X PUT /api/apps/{slug} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/apps/{slug} HTTP/1.1

Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: '/api/apps/{slug}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('/api/apps/{slug}',
{
  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'
}

result = RestClient.put '/api/apps/{slug}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/apps/{slug}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}");
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"},

    }

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

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

PUT /apps/{slug}

Body parameter

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

name: string
slug: string
description: string
account: string
active: false
createdAt: '2018-12-09T04:42:21Z'
createdBy: string
modifiedAt: '2018-12-09T04:42:21Z'
modifiedBy: string
id: string

<?xml version="1.0" encoding="UTF-8" ?>
<app>
  <name>string</name>
  <slug>string</slug>
  <description>string</description>
  <account>string</account>
  <active>false</active>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</app>

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
body	body	app	false	none

Example responses

200 Response

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<app>
  <name>string</name>
  <slug>string</slug>
  <description>string</description>
  <account>string</account>
  <active>false</active>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</app>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	app

app.deleteApp

Code samples

# You can also use wget
curl -X DELETE /api/apps/{slug}

DELETE /api/apps/{slug} HTTP/1.1

$.ajax({
  url: '/api/apps/{slug}',
  method: 'delete',

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

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

fetch('/api/apps/{slug}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete '/api/apps/{slug}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('/api/apps/{slug}', params={

)

print r.json()

URL obj = new URL("/api/apps/{slug}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/apps/{slug}", data)
    req.Header = headers

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

DELETE /apps/{slug}

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none

Responses

Status	Meaning	Description	Schema
204	No Content	Request was successful	None

app.getConfigs

Code samples

# You can also use wget
curl -X GET /api/apps/{slug}/configs \
  -H 'Accept: application/json'

GET /api/apps/{slug}/configs HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps/{slug}/configs',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/configs',
{
  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'
}

result = RestClient.get '/api/apps/{slug}/configs',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/apps/{slug}/configs', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/configs");
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"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/apps/{slug}/configs", data)
    req.Header = headers

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

GET /apps/{slug}/configs

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none

Example responses

200 Response

[
  {
    "app": "string",
    "env": "string",
    "json": {},
    "auth_key": "string",
    "account": "string",
    "status": "draft",
    "createdAt": "2018-12-09T04:42:21Z",
    "createdBy": "string",
    "modifiedAt": "2018-12-09T04:42:21Z",
    "modifiedBy": "string",
    "id": "string"
  }
]

<?xml version="1.0" encoding="UTF-8" ?>
<app>string</app>
<env>string</env>
<json/>
<auth_key>string</auth_key>
<account>string</account>
<status>draft</status>
<createdAt>2018-12-09T04:42:21Z</createdAt>
<createdBy>string</createdBy>
<modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
<modifiedBy>string</modifiedBy>
<id>string</id>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[config]	false	none	none
» app	string	true	none	none
» env	string	true	none	none
» json	object	false	none	none
» auth_key	string	false	none	none
» account	string	true	none	none
» status	string	true	none	none
» createdAt	string(date-time)	false	none	none
» createdBy	string	false	none	none
» modifiedAt	string(date-time)	false	none	none
» modifiedBy	string	false	none	none
» id	string	false	none	none

app.createConfig

Code samples

# You can also use wget
curl -X POST /api/apps/{slug}/configs \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /api/apps/{slug}/configs HTTP/1.1

Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: '/api/apps/{slug}/configs',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/configs',
{
  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'
}

result = RestClient.post '/api/apps/{slug}/configs',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/apps/{slug}/configs', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/configs");
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"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api/apps/{slug}/configs", data)
    req.Header = headers

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

POST /apps/{slug}/configs

Body parameter

{}

{}

<?xml version="1.0" encoding="UTF-8" ?>

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
body	body	app.createConfigConfig	true	none

Example responses

200 Response

{
  "app": "string",
  "env": "string",
  "json": {},
  "auth_key": "string",
  "account": "string",
  "status": "draft",
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<config>
  <app>string</app>
  <env>string</env>
  <json/>
  <auth_key>string</auth_key>
  <account>string</account>
  <status>draft</status>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</config>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	config

app.getConfig

Code samples

# You can also use wget
curl -X GET /api/apps/{slug}/configs/{env} \
  -H 'Accept: application/json'

GET /api/apps/{slug}/configs/{env} HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps/{slug}/configs/{env}',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/configs/{env}',
{
  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'
}

result = RestClient.get '/api/apps/{slug}/configs/{env}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/apps/{slug}/configs/{env}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/configs/{env}");
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"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/apps/{slug}/configs/{env}", data)
    req.Header = headers

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

GET /apps/{slug}/configs/{env}

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
env	path	string	true	none
compiled	query	boolean	false	none

Example responses

200 Response

{
  "app": "string",
  "env": "string",
  "json": {},
  "auth_key": "string",
  "account": "string",
  "status": "draft",
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<config>
  <app>string</app>
  <env>string</env>
  <json/>
  <auth_key>string</auth_key>
  <account>string</account>
  <status>draft</status>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</config>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	config

app.updateConfig

Code samples

# You can also use wget
curl -X PUT /api/apps/{slug}/configs/{env} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /api/apps/{slug}/configs/{env} HTTP/1.1

Content-Type: application/json
Accept: application/json

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

};

$.ajax({
  url: '/api/apps/{slug}/configs/{env}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/configs/{env}',
{
  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'
}

result = RestClient.put '/api/apps/{slug}/configs/{env}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/apps/{slug}/configs/{env}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/configs/{env}");
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"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/apps/{slug}/configs/{env}", data)
    req.Header = headers

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

PUT /apps/{slug}/configs/{env}

Body parameter

{}

{}

<?xml version="1.0" encoding="UTF-8" ?>

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
env	path	string	true	none
body	body	app.createConfigConfig	true	none

Example responses

200 Response

{
  "app": "string",
  "env": "string",
  "json": {},
  "auth_key": "string",
  "account": "string",
  "status": "draft",
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

<?xml version="1.0" encoding="UTF-8" ?>
<config>
  <app>string</app>
  <env>string</env>
  <json/>
  <auth_key>string</auth_key>
  <account>string</account>
  <status>draft</status>
  <createdAt>2018-12-09T04:42:21Z</createdAt>
  <createdBy>string</createdBy>
  <modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
  <modifiedBy>string</modifiedBy>
  <id>string</id>
</config>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	config

app.deleteConfig

Code samples

# You can also use wget
curl -X DELETE /api/apps/{slug}/configs/{env}

DELETE /api/apps/{slug}/configs/{env} HTTP/1.1

$.ajax({
  url: '/api/apps/{slug}/configs/{env}',
  method: 'delete',

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

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

fetch('/api/apps/{slug}/configs/{env}',
{
  method: 'DELETE'

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

require 'rest-client'
require 'json'

result = RestClient.delete '/api/apps/{slug}/configs/{env}',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.delete('/api/apps/{slug}/configs/{env}', params={

)

print r.json()

URL obj = new URL("/api/apps/{slug}/configs/{env}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/apps/{slug}/configs/{env}", data)
    req.Header = headers

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

DELETE /apps/{slug}/configs/{env}

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
env	path	string	true	none

Responses

Status	Meaning	Description	Schema
204	No Content	Request was successful	None

app.getKeys

Code samples

# You can also use wget
curl -X GET /api/apps/{slug}/keys \
  -H 'Accept: application/json'

GET /api/apps/{slug}/keys HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps/{slug}/keys',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/keys',
{
  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'
}

result = RestClient.get '/api/apps/{slug}/keys',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/apps/{slug}/keys', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/keys");
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"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/apps/{slug}/keys", data)
    req.Header = headers

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

GET /apps/{slug}/keys

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none

Example responses

200 Response

[
  {
    "type": "string",
    "key": "string",
    "account": "string",
    "app": "string",
    "env": "string",
    "createdAt": "2018-12-09T04:42:21Z",
    "createdBy": "string",
    "modifiedAt": "2018-12-09T04:42:21Z",
    "modifiedBy": "string",
    "id": "string"
  }
]

<?xml version="1.0" encoding="UTF-8" ?>
<type>string</type>
<key>string</key>
<account>string</account>
<app>string</app>
<env>string</env>
<createdAt>2018-12-09T04:42:21Z</createdAt>
<createdBy>string</createdBy>
<modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
<modifiedBy>string</modifiedBy>
<id>string</id>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[key]	false	none	none
» type	string	true	none	none
» key	string	true	none	none
» account	string	true	none	none
» app	string	false	none	none
» env	string	false	none	none
» createdAt	string(date-time)	false	none	none
» createdBy	string	false	none	none
» modifiedAt	string(date-time)	false	none	none
» modifiedBy	string	false	none	none
» id	string	false	none	none

app.setKey

Code samples

# You can also use wget
curl -X PUT /api/apps/{slug}/keys \
  -H 'Accept: application/json'

PUT /api/apps/{slug}/keys HTTP/1.1

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '/api/apps/{slug}/keys',
  method: 'put',

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

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

const headers = {
  'Accept':'application/json'

};

fetch('/api/apps/{slug}/keys',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.put '/api/apps/{slug}/keys',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/apps/{slug}/keys', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/apps/{slug}/keys");
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{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/apps/{slug}/keys", data)
    req.Header = headers

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

PUT /apps/{slug}/keys

Parameters

Parameter	In	Type	Required	Description
slug	path	string	true	none
env	query	string	false	none
key	query	string	false	none

Example responses

200 Response

[
  {
    "type": "string",
    "key": "string",
    "account": "string",
    "app": "string",
    "env": "string",
    "createdAt": "2018-12-09T04:42:21Z",
    "createdBy": "string",
    "modifiedAt": "2018-12-09T04:42:21Z",
    "modifiedBy": "string",
    "id": "string"
  }
]

<?xml version="1.0" encoding="UTF-8" ?>
<type>string</type>
<key>string</key>
<account>string</account>
<app>string</app>
<env>string</env>
<createdAt>2018-12-09T04:42:21Z</createdAt>
<createdBy>string</createdBy>
<modifiedAt>2018-12-09T04:42:21Z</modifiedAt>
<modifiedBy>string</modifiedBy>
<id>string</id>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[key]	false	none	none
» type	string	true	none	none
» key	string	true	none	none
» account	string	true	none	none
» app	string	false	none	none
» env	string	false	none	none
» createdAt	string(date-time)	false	none	none
» createdBy	string	false	none	none
» modifiedAt	string(date-time)	false	none	none
» modifiedBy	string	false	none	none
» id	string	false	none	none

config

A config represents a single environment's specific key/value pairs. Each config is tied to an app.

config.retrieveConfigByAuthKey

Code samples

# You can also use wget
curl -X GET /api/configs/retrieve \
  -H 'Accept: application/json' \
  -H 'X-Config-Key: string'

GET /api/configs/retrieve HTTP/1.1

Accept: application/json
X-Config-Key: string

var headers = {
  'Accept':'application/json',
  'X-Config-Key':'string'

};

$.ajax({
  url: '/api/configs/retrieve',
  method: 'get',

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

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

const headers = {
  'Accept':'application/json',
  'X-Config-Key':'string'

};

fetch('/api/configs/retrieve',
{
  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',
  'X-Config-Key' => 'string'
}

result = RestClient.get '/api/configs/retrieve',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-Config-Key': 'string'
}

r = requests.get('/api/configs/retrieve', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/configs/retrieve");
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"},
        "X-Config-Key": []string{"string"},

    }

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

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

GET /configs/retrieve

Parameters

Parameter	In	Type	Required	Description
X-Config-Key	header	string	true	none

Example responses

200 Response

{}

<?xml version="1.0" encoding="UTF-8" ?>

Responses

Status	Meaning	Description	Schema
200	OK	Request was successful	Inline

Response Schema

Schemas

app

{
  "name": "string",
  "slug": "string",
  "description": "string",
  "account": "string",
  "active": false,
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	true	none	none
slug	string	false	none	none
description	string	false	none	none
account	string	true	none	none
active	boolean	false	none	none
createdAt	string(date-time)	false	none	none
createdBy	string	false	none	none
modifiedAt	string(date-time)	false	none	none
modifiedBy	string	false	none	none
id	string	false	none	none

config

{
  "app": "string",
  "env": "string",
  "json": {},
  "auth_key": "string",
  "account": "string",
  "status": "draft",
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
app	string	true	none	none
env	string	true	none	none
json	object	false	none	none
auth_key	string	false	none	none
account	string	true	none	none
status	string	true	none	none
createdAt	string(date-time)	false	none	none
createdBy	string	false	none	none
modifiedAt	string(date-time)	false	none	none
modifiedBy	string	false	none	none
id	string	false	none	none

key

{
  "type": "string",
  "key": "string",
  "account": "string",
  "app": "string",
  "env": "string",
  "createdAt": "2018-12-09T04:42:21Z",
  "createdBy": "string",
  "modifiedAt": "2018-12-09T04:42:21Z",
  "modifiedBy": "string",
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
type	string	true	none	none
key	string	true	none	none
account	string	true	none	none
app	string	false	none	none
env	string	false	none	none
createdAt	string(date-time)	false	none	none
createdBy	string	false	none	none
modifiedAt	string(date-time)	false	none	none
modifiedBy	string	false	none	none
id	string	false	none	none