API reference

unbind service instance

• path: /services/{service}/instances/{instance}/{app}
• produce: application/x-json-stream
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

list app certificates

• path: /apps/{app}/certificate
• consume: application/x-www-form-urlencoded
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: App not found

grant access to app

• path: /apps/{app}/teams/{team}
• method: PUT
• 200: Access granted
• 401: Unauthorized
• 404: App or team not found
• 409: Grant already exists

run commands

• path: /apps/{app}/run
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

set unit status

• path: /apps/{app}/units/{unit}
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App or unit not found
• 401: Unauthorized

app log

• path: /apps/{app}/log
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

app list

• path: /apps
• produce: application/json
• method: GET
• 200: List apps
• 401: Unauthorized
• 204: No content

remove units

• path: /apps/{name}/units
• produce: application/x-json-stream
• method: DELETE
• 200: Units removed
• 400: Invalid data
• 403: Not enough reserved units
• 404: App not found
• 401: Unauthorized

unset app certificate

• path: /apps/{app}/certificate
• consume: application/x-www-form-urlencoded
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

set envs

• path: /apps/{app}/env
• produce: application/x-json-stream
• consume: application/json
• method: POST
• 200: Envs updated
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

unset envs

• path: /apps/{app}/env
• produce: application/x-json-stream
• method: DELETE
• 200: Envs removed
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

get envs

• path: /apps/{app}/env
• produce: application/x-json-stream
• method: GET
• 200: OK
• 401: Unauthorized
• 404: App not found

bind service instance

• path: /services/{service}/instances/{instance}/{app}
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

app update

• path: /apps/{name}
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: App updated
• 400: Invalid new pool
• 404: Not found
• 401: Unauthorized

app stop

• path: /apps/{app}/stop
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

metric envs

• path: /apps/{app}/metric/envs
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: App not found

app sleep

• path: /apps/{app}/sleep
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

app swap

• path: /swap
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 401: Unauthorized
• 404: App not found
• 200: Ok
• 409: App locked
• 412: Number of units or platform don't match

app unlock

• path: /apps/{app}/lock
• produce: application/json
• method: DELETE
• 410: Not available anymore

register unit

• path: /apps/{app}/units/register
• produce: application/json
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

rebuild routes

• path: /apps/{app}/routes
• produce: application/json
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

set node status

• path: /node/status
• produce: application/json
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App or unit not found
• 401: Unauthorized

set cname

• path: /apps/{app}/cname
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

app restart

• path: /apps/{app}/restart
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

app start

• path: /apps/{app}/start
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

app version delete

• path: /apps/{app}/versions/{version}
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: DELETE
• 200: Ok
• 401: Unauthorized
• 404: Version not found

unset cname

• path: /apps/{app}/cname
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

set app certificate

• path: /apps/{app}/certificate
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

remove app

• path: /apps/{name}
• produce: application/x-json-stream
• method: DELETE
• 200: App removed
• 401: Unauthorized
• 404: Not found

app create

• path: /apps
• produce: application/json
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: App created
• 403: Quota exceeded
• 401: Unauthorized
• 409: App already exists

app log

• path: /apps/{app}/log
• produce: application/x-json-stream
• method: GET
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

add units

• path: /apps/{name}/units
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Units added
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

revoke access to app

• path: /apps/{app}/teams/{team}
• method: DELETE
• 200: Access revoked
• 401: Unauthorized
• 403: Forbidden
• 404: App or team not found

app info

• path: /apps/{name}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Not found

team update

• path: /teams/{name}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Team updated
• 400: Invalid data
• 404: Team not found
• 401: Unauthorized

team info

• path: /teams/{name}
• produce: application/json
• method: GET
• 200: Info team
• 401: Unauthorized
• 404: Not found

user list

• path: /users
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

change password

• path: /users/password
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Ok
• 400: Invalid data
• 403: Forbidden
• 404: Not found
• 401: Unauthorized

remove team

• path: /teams/{name}
• method: DELETE
• 200: Team removed
• 401: Unauthorized
• 403: Forbidden
• 404: Not found

team create

• path: /teams
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Team created
• 401: Unauthorized
• 409: Team already exists

user create

• path: /users
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: User created
• 403: Forbidden
• 401: Unauthorized
• 409: User already exists

login

• path: /auth/login
• produce: application/json
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 403: Forbidden
• 404: Not found
• 401: Unauthorized

get auth scheme

• path: /auth/scheme
• produce: application/json
• method: GET
• 200: OK

regenerate token

• path: /users/api-key
• produce: application/json
• method: POST
• 200: OK
• 401: Unauthorized
• 404: User not found

reset password

• path: /users/{email}/password
• method: POST
• 200: Ok
• 400: Invalid data
• 403: Forbidden
• 404: Not found
• 401: Unauthorized

team list

• path: /teams
• produce: application/json
• method: GET
• 200: List teams
• 401: Unauthorized
• 204: No content

show token

• path: /users/api-key
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: User not found

user info

• path: /users/info
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

logout

• path: /users/tokens
• method: DELETE
• 200: Ok

remove user

• path: /users
• method: DELETE
• 200: User removed
• 401: Unauthorized
• 404: Not found

list autoscale history

• path: /autoscale
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 204: No content

autoscale run

• path: /autoscale/run
• produce: application/x-json-stream
• method: POST
• 200: Ok
• 401: Unauthorized

get autoscale config

• path: /autoscale/config
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

autoscale rules list

• path: /autoscale/rules
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 204: No content

autoscale set rule

• path: /autoscale/rules
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

delete autoscale rule

• path: /autoscale/rules/{id}
• method: DELETE
• 200: Ok
• 401: Unauthorized
• 404: Not found

app build

• path: /apps/{appname}/build
• consume: application/x-www-form-urlencoded
• method: POST
• 200: OK
• 400: Invalid data
• 403: Forbidden
• 404: Not found

list provisioners

• path: /provisioner
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 204: No Content

create provisioner cluster

• path: /provisioner/clusters
• produce: application/x-json-stream
• consume: application/json
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Pool does not exist
• 401: Unauthorized
• 409: Cluster already exists

update provisioner cluster

• path: /provisioner/clusters/{name}
• produce: application/x-json-stream
• consume: application/json
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Cluster not found
• 401: Unauthorized

list provisioner clusters

• path: /provisioner/clusters
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 204: No Content

provisioner cluster info

• path: /provisioner/clusters/{name}
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: Cluster not found

delete provisioner cluster

• path: /provisioner/clusters/{name}
• produce: application/x-json-stream
• method: DELETE
• 200: Ok
• 401: Unauthorized
• 404: Cluster not found

dump goroutines

• path: /debug/goroutines
• method: GET
• 200: Ok

deploy diff

• path: /apps/{appname}/diff
• consume: application/x-www-form-urlencoded
• method: POST
• 410: Gone

deploy info

• path: /deploys/{deploy}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Not found

rebuild

• path: /apps/{app}/deploy/rebuild
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: OK
• 400: Invalid data
• 403: Forbidden
• 404: Not found

rollback update

• path: /apps/{app}/deploy/rollback/update
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Rollback updated
• 400: Invalid data
• 403: Forbidden

app deploy

• path: /apps/{appname}/deploy
• consume: application/x-www-form-urlencoded
• method: POST
• 200: OK
• 400: Invalid data
• 403: Forbidden
• 404: Not found

rollback

• path: /apps/{app}/deploy/rollback
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: OK
• 400: Invalid data
• 403: Forbidden
• 404: Not found

deploy list

• path: /deploys
• produce: application/json
• method: GET
• 200: OK
• 204: No content

event block list

• path: /events/blocks
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 204: No content

add event block

• path: /events/blocks
• consume: application/x-www-form-urlencoded
• method: POST
• 200: OK
• 400: Invalid data or empty reason
• 401: Unauthorized

remove event block

• path: /events/blocks/{uuid}
• method: DELETE
• 200: OK
• 400: Invalid uuid
• 404: Active block with provided uuid not found
• 401: Unauthorized

event list

• path: /events
• produce: application/json
• method: GET
• 200: OK
• 204: No content

kind list

• path: /events/kinds
• produce: application/json
• method: GET
• 200: OK
• 204: No content

event info

• path: /events/{uuid}
• produce: application/json
• method: GET
• 200: OK
• 400: Invalid uuid
• 404: Not found
• 401: Unauthorized

event cancel

• path: /events/{uuid}/cancel
• produce: application/json
• method: POST
• 400: Invalid uuid or empty reason
• 401: Unauthorized
• 404: Not found
• 204: OK

docker healing history

• path: /docker/healing
• produce: application/json
• method: GET
• 200: Ok
• 400: Invalid data
• 204: No content
• 401: Unauthorized

healthcheck

• path: /healthcheck
• method: GET
• 200: OK
• 500: Internal server error

template update

• path: /iaas/templates/{template_name}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: OK
• 400: Invalid data
• 404: Not found
• 401: Unauthorized

machine list

• path: /iaas/machines
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

machine destroy

• path: /iaas/machines/{machine_id}
• method: DELETE
• 200: OK
• 400: Invalid data
• 404: Not found
• 401: Unauthorized

machine template list

• path: /iaas/templates
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

template create

• path: /iaas/templates
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Template created
• 401: Unauthorized
• 409: Existent template

template destroy

• path: /iaas/templates/{template_name}
• method: DELETE
• 200: OK
• 401: Unauthorized
• 404: Not found

index

• path: /
• method: GET
• 200: OK

api info

• path: /info
• produce: application/json
• method: GET
• 200: OK

add install host

• path: /install/hosts
• produce: application/json
• consume: application/x-www-form-urlencoded
• method: POST
• 201: Host added
• 401: Unauthorized

install host info

• path: /install/hosts/{name}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Not Found

list install hosts

• path: /install/hosts
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

remove node

• path: /{provisioner}/node/{address}
• method: DELETE
• 200: Ok
• 401: Unauthorized
• 404: Not found

list units by node

• path: /{provisioner}/node/{address}/containers
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: Not found
• 204: No content

node healing update

• path: /healing/node
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 401: Unauthorized

node info

• path: /node/{address}
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: Not found

list units by app

• path: /docker/node/apps/{appname}/containers
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: Not found
• 204: No content

node healing info

• path: /healing/node
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

remove node healing

• path: /healing/node
• produce: application/json
• method: DELETE
• 200: Ok
• 401: Unauthorized

add node

• path: /node
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 201: Ok
• 404: Not found
• 401: Unauthorized

list nodes

• path: /{provisioner}/node
• produce: application/json
• method: GET
• 200: Ok
• 204: No content

update nodes

• path: /{provisioner}/node
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Ok
• 400: Invalid data
• 404: Not found
• 401: Unauthorized

rebalance units in nodes

• path: /node/rebalance
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

remove node container list

• path: /docker/nodecontainers
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

node container create

• path: /docker/nodecontainers
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invald data
• 401: Unauthorized

node container info

• path: /docker/nodecontainers/{name}
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: Not found

node container update

• path: /docker/nodecontainers/{name}
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invald data
• 404: Not found
• 401: Unauthorized

remove node container

• path: /docker/nodecontainers/{name}
• method: DELETE
• 200: Ok
• 401: Unauthorized
• 404: Not found

node container upgrade

• path: /docker/nodecontainers/{name}/upgrade
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invald data
• 404: Not found
• 401: Unauthorized

remove permission

• path: /roles/{name}/permissions/{permission}
• method: DELETE
• 200: Permission removed
• 401: Unauthorized
• 404: Not found

assign role to token

• path: /roles/{name}/token
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Role or team token not found
• 401: Unauthorized

assign role to user

• path: /roles/{name}/user
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Role not found
• 401: Unauthorized

list permissions

• path: /permissions
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

list default roles

• path: /role/default
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

dissociate role from group

• path: /roles/{name}/group/{group_name}
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: Role not found
• 401: Unauthorized

remove role

• path: /roles/{name}
• method: DELETE
• 200: Role removed
• 401: Unauthorized
• 404: Role not found
• 412: Role with users

role info

• path: /roles/{name}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Role not found

add permissions

• path: /roles/{name}/permissions
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 401: Unauthorized
• 409: Permission not allowed

add default role

• path: /role/default
• method: POST
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

updates a role

• path: /roles
• method: PUT
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

dissociate role from user

• path: /roles/{name}/user/{email}
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: Role not found
• 401: Unauthorized

dissociate role from token

• path: /roles/{name}/token/{token_id}
• method: DELETE
• 200: Ok
• 400: Invalid data
• 404: Role or team token not found
• 401: Unauthorized

assign role to group

• path: /roles/{name}/group
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Role not found
• 401: Unauthorized

role create

• path: /roles
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Role created
• 401: Unauthorized
• 409: Role already exists

role list

• path: /roles
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized

remove default role

• path: /role/default
• method: DELETE
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

remove plan

• path: /plans/{name}
• method: DELETE
• 200: Plan removed
• 401: Unauthorized
• 404: Plan not found

plan create

• path: /plans
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Plan created
• 401: Unauthorized
• 409: Plan already exists

plan list

• path: /plans
• produce: application/json
• method: GET
• 200: OK
• 204: No content

add platform

• path: /platforms
• produce: application/x-json-stream
• consume: multipart/form-data
• method: POST
• 200: Platform created
• 400: Invalid data
• 401: Unauthorized

update platform

• path: /platforms/{name}
• produce: application/x-json-stream
• method: PUT
• 200: Platform updated
• 401: Unauthorized
• 404: Not found

remove platform

• path: /platforms/{name}
• method: DELETE
• 200: Platform removed
• 401: Unauthorized
• 404: Not found

platform list

• path: /platforms
• produce: application/json
• method: GET
• 200: List platforms
• 401: Unauthorized
• 204: No content

platform info

• path: /platforms/{name}
• produce: application/json
• method: GET
• 200: Platform info
• 401: Unauthorized
• 404: NotFound

rollback platform

• path: /platforms/{name}/rollback
• produce: application/x-json-stream
• method: POST
• 200: OK
• 400: BadRequest
• 404: Not found
• 401: Unauthorized

pool get

• path: /pools/{name}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Not found

add team too pool

• path: /pools/{name}/team
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Pool updated
• 401: Unauthorized
• 400: Invalid data
• 404: Pool not found

set a pool constraint

• path: /constraints
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: OK
• 401: Unauthorized

pool list

• path: /pools
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 204: No content

pool create

• path: /pools
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Pool created
• 401: Unauthorized
• 409: Pool already exists

remove pool

• path: /pools/{name}
• method: DELETE
• 200: Pool removed
• 401: Unauthorized
• 403: Pool still has apps
• 404: Pool not found

remove team from pool

• path: /pools/{name}/team
• method: DELETE
• 200: Pool updated
• 401: Unauthorized
• 400: Invalid data
• 404: Pool not found

pool update

• path: /pools/{name}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Pool updated
• 401: Unauthorized
• 404: Pool not found
• 409: Default pool already defined

pool constraints list

• path: /constraints
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 204: No content

application quota

• path: /apps/{app}/quota
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Application not found

update application quota

• path: /apps/{app}/quota
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Quota updated
• 400: Invalid data
• 403: Limit lower than allocated
• 404: Application not found
• 401: Unauthorized

team quota

• path: /teams/{name}/quota
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Team not found

update team quota

• path: /teams/{name}/quota
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Quota updated
• 400: Invalid data
• 403: Limit lower than allocated value
• 404: Team not found
• 401: Unauthorized

user quota

• path: /users/{email}/quota
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: User not found

update user quota

• path: /users/{email}/quota
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Quota updated
• 400: Invalid data
• 403: Limit lower than allocated value
• 404: User not found
• 401: Unauthorized

router list

• path: /routers
• produce: application/json
• method: GET
• 200: OK
• 204: No content

add app router

• path: /app/{app}/routers
• produce: application/json
• method: POST
• 200: OK
• 400: Invalid request
• 404: App or router not found

update app router

• path: /app/{app}/routers/{name}
• produce: application/json
• method: PUT
• 200: OK
• 400: Invalid request
• 404: App or router not found

list app routers

• path: /app/{app}/routers
• produce: application/json
• method: GET
• 200: OK
• 204: No content
• 404: App not found

toggle an app version as routable

• path: /app/{app}/routable
• method: POST
• 200: OK
• 400: Bad request
• 404: App not found
• 401: Not authorized

router add

• path: /routers
• method: POST
• 400: Invalid router
• 201: Created
• 409: Router already exists

router delete

• path: /routers/{name}
• method: DELETE
• 200: OK
• 404: Router not found

router update

• path: /routers/{name}
• method: PUT
• 200: OK
• 400: Invalid router
• 404: Router not found

delete app router

• path: /app/{app}/routers/{router}
• produce: application/json
• method: DELETE
• 200: OK
• 404: App or router not found

saml metadata

• path: /auth/saml
• produce: application/xml
• method: GET
• 200: Ok
• 400: Invalid data

saml callback

• path: /auth/saml
• method: POST
• 200: Ok
• 400: Invalid data

units autoscale info

• path: /apps/{app}/units/autoscale
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized
• 404: App not found

add unit auto scale

• path: /apps/{app}/units/autoscale
• consume: application/json
• method: POST
• 200: Ok
• 400: Invalid data
• 404: App not found
• 401: Unauthorized

remove unit auto scale

• path: /apps/{app}/units/autoscale
• consume: application/json
• method: POST
• 200: Ok
• 401: Unauthorized
• 404: App not found

grant access to a service

• path: /services/{service}/team/{team}
• method: PUT
• 200: Service updated
• 400: Team not found
• 404: Service not found
• 401: Unauthorized
• 409: Team already has access to this service

revoke access to a service

• path: /services/{service}/team/{team}
• method: DELETE
• 200: Access revoked
• 400: Team not found
• 404: Service not found
• 401: Unauthorized
• 409: Team does not has access to this service

service list

• path: /services
• produce: application/json
• method: GET
• 200: List services
• 401: Unauthorized
• 204: No content

service update

• path: /services/{name}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Service updated
• 400: Invalid data
• 403: Forbidden (team is not the owner)
• 404: Service not found
• 401: Unauthorized

service delete

• path: /services/{name}
• method: DELETE
• 200: Service removed
• 401: Unauthorized
• 403: Forbidden (team is not the owner or service with instances)
• 404: Service not found

service proxy

• path: /services/proxy/service/{service}
• method: *
• 401: Unauthorized
• 404: Service not found

service create

• path: /services
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Service created
• 401: Unauthorized
• 409: Service already exists

change service documentation

• path: /services/{name}/doc
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Documentation updated
• 401: Unauthorized
• 403: Forbidden (team is not the owner or service with instances)

service broker list

• path: /brokers
• produce: application/json
• method: GET
• 200: List service brokers
• 401: Unauthorized
• 204: No content

Add service broker

• path: /brokers
• method: POST
• 401: Unauthorized
• 409: Broker already exists
• 201: Service broker created

Update service broker

• path: /brokers/{broker}
• method: PUT
• 200: Service broker updated
• 401: Unauthorized
• 404: Not Found

Delete service broker

• path: /brokers/{broker}
• method: DELETE
• 200: Service broker deleted
• 401: Unauthorized
• 404: Not Found

service instance info

• path: /services/{service}/instances/{instance}
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Service instance not found

revoke access to service instance

• path: /services/{service}/instances/permission/{instance}/{team}
• method: DELETE
• 200: Access revoked
• 401: Unauthorized
• 404: Service instance not found

service instance create

• path: /services/{service}/instances
• consume: application/x-www-form-urlencoded
• method: POST
• 400: Invalid data
• 201: Service created
• 401: Unauthorized
• 409: Service already exists

remove service instance

• path: /services/{name}/instances/{instance}
• produce: application/x-json-stream
• method: DELETE
• 200: Service removed
• 400: Bad request
• 404: Service instance not found
• 401: Unauthorized

service instance list

• path: /services/instances
• produce: application/json
• method: GET
• 200: List services instances
• 401: Unauthorized
• 204: No content

service doc

• path: /services/{name}/doc
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Not found

service instance proxy

• path: /services/{service}/proxy/{instance}
• method: *
• 401: Unauthorized
• 404: Instance not found

service info

• path: /services/{name}
• produce: application/json
• method: GET
• 200: OK

service plans

• path: /services/{name}/plans
• produce: application/json
• method: GET
• 200: OK
• 401: Unauthorized
• 404: Service not found

grant access to service instance

• path: /services/{service}/instances/permission/{instance}/{team}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Access granted
• 401: Unauthorized
• 404: Service instance not found

service instance update

• path: /services/{service}/instances/{instance}
• consume: application/x-www-form-urlencoded
• method: PUT
• 200: Service instance updated
• 400: Invalid data
• 404: Service instance not found
• 401: Unauthorized

service instance status

• path: /services/{service}/instances/{instance}/status
• method: GET
• 200: List services instances
• 401: Unauthorized
• 404: Service instance not found

app shell

• path: /apps/{name}/shell
• produce: Websocket connection upgrade
• method: GET
• 101: Switch Protocol to websocket

token delete

• path: /tokens/{token_id}
• produce: application/json
• method: DELETE
• 200: Token created
• 401: Unauthorized
• 404: Token not found

token list

• path: /tokens
• produce: application/json
• method: GET
• 200: List tokens
• 401: Unauthorized
• 204: No content

token info

• path: /tokens/{token_id}
• produce: application/json
• method: GET
• 200: Get token
• 401: Unauthorized

token create

• path: /tokens
• produce: application/json
• method: POST
• 401: Unauthorized
• 409: Token already exists
• 201: Token created

token update

• path: /tokens/{token_id}
• produce: application/json
• method: PUT
• 200: Token updated
• 401: Unauthorized
• 404: Token not found

volume plan list

• path: /volumeplans
• produce: application/json
• method: GET
• 200: List volume plans
• 401: Unauthorized

volume bind

• path: /volumes/{name}/bind
• produce: application/json
• method: POST
• 200: Volume binded
• 401: Unauthorized
• 404: Volume not found
• 409: Volume bind already exists

volume unbind

• path: /volumes/{name}/bind
• produce: application/json
• method: DELETE
• 200: Volume unbinded
• 401: Unauthorized
• 404: Volume not found

volume info

• path: /volumes/{name}
• produce: application/json
• method: GET
• 200: Show volume
• 401: Unauthorized
• 404: Volume not found

volume create

• path: /volumes
• produce: application/json
• method: POST
• 401: Unauthorized
• 409: Volume already exists
• 201: Volume created

volume delete

• path: /volumes/{name}
• produce: application/json
• method: DELETE
• 200: Volume deleted
• 401: Unauthorized
• 404: Volume not found

volume list

• path: /volumes
• produce: application/json
• method: GET
• 200: List volumes
• 401: Unauthorized
• 204: No content

volume update

• path: /volumes/{name}
• produce: application/json
• method: POST
• 200: Volume updated
• 401: Unauthorized
• 404: Volume not found

webhook list

• path: /events/webhooks
• produce: application/json
• method: GET
• 200: List webhooks
• 204: No content

webhook info

• path: /events/webhooks/{name}
• produce: application/json
• method: GET
• 200: Get webhook
• 401: Unauthorized
• 404: Not found

webhook create

• path: /events/webhooks
• method: POST
• 200: Webhook created
• 401: Unauthorized
• 400: Invalid webhook
• 409: Webhook already exists

webhook update

• path: /events/webhooks/{name}
• method: PUT
• 200: Webhook updated
• 401: Unauthorized
• 400: Invalid webhook
• 404: Webhook not found

webhook delete

• path: /events/webhooks/{name}
• method: DELETE
• 200: Webhook deleted
• 401: Unauthorized
• 404: Webhook not found

logs config set

• path: /docker/logs
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 401: Unauthorized

move container

• path: /docker/container/{id}/move
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Not found
• 401: Unauthorized

logs config

• path: /docker/logs
• produce: application/json
• method: GET
• 200: Ok
• 401: Unauthorized

move containers

• path: /docker/containers/move
• produce: application/x-json-stream
• consume: application/x-www-form-urlencoded
• method: POST
• 200: Ok
• 400: Invalid data
• 404: Not found
• 401: Unauthorized