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

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:

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
Shell HTTP JavaScript Node.JS Ruby Python Java Go