NAV Navigation
Shell HTTP JavaScript Node.js Ruby Python Java Go

Wekan REST API v2.71

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 REST API allows you to control and extend Wekan with ease.

If you are an end-user and not a dev or a tester, create an issue to request new APIs.

All API calls in the documentation are made using curl. However, you are free to use Java / Python / PHP / Golang / Ruby / Swift / Objective-C / Rust / Scala / C# or any other programming languages.

Production Security Concerns

When calling a production Wekan server, ensure it is running via HTTPS and has a valid SSL Certificate. The login method requires you to post your username and password in plaintext, which is why we highly suggest only calling the REST login api over HTTPS. Also, few things to note:

Authentication

Login

login

Code samples

# You can also use wget
curl -X POST /users/login \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*'

POST /users/login HTTP/1.1

Content-Type: application/x-www-form-urlencoded
Accept: */*

var headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*'

};

$.ajax({
  url: '/users/login',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "username": "string",
  "password": "pa$$word"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*'

};

fetch('/users/login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/x-www-form-urlencoded',
  'Accept' => '*/*'
}

result = RestClient.post '/users/login',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*'
}

r = requests.post('/users/login', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        
    }

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

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

POST /users/login

Login with REST API

Body parameter

username: string
password: pa$$word

Parameters

Name In Type Required Description
body body object false none
» username body string true Your username
» password body string(password) true Your password

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Successful authentication Inline
400 Bad Request Error in authentication Inline
default Default Error in authentication None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» id string false none none
» token string false none none
» tokenExpires string false none none

Status Code 400

Name Type Required Restrictions Description
» error number false none none
» reason string false none none

register

Code samples

# You can also use wget
curl -X POST /users/register \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*'

POST /users/register HTTP/1.1

Content-Type: application/x-www-form-urlencoded
Accept: */*

var headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*'

};

$.ajax({
  url: '/users/register',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "username": "string",
  "password": "pa$$word",
  "email": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*'

};

fetch('/users/register',
{
  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/x-www-form-urlencoded',
  'Accept' => '*/*'
}

result = RestClient.post '/users/register',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*'
}

r = requests.post('/users/register', params={

}, headers = headers)

print r.json()

URL obj = new URL("/users/register");
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/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        
    }

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

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

POST /users/register

Register with REST API

Notes:

Body parameter

username: string
password: pa$$word
email: string

Parameters

Name In Type Required Description
body body object false none
» username body string true Your username
» password body string(password) true Your password
» email body string true Your email

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Successful registration Inline
400 Bad Request Error in registration Inline
default Default Error in registration None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» id string false none none
» token string false none none
» tokenExpires string false none none

Status Code 400

Name Type Required Restrictions Description
» error number false none none
» reason string false none none

Boards

get_public_boards

Code samples

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

GET /api/boards HTTP/1.1

Accept: application/json

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

};

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

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

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

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

};

fetch('/api/boards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards

Get all public boards

Example responses

200 Response

[
  {
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

new_board

Code samples

# You can also use wget
curl -X POST /api/boards \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

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

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

const fetch = require('node-fetch');
const inputBody = '{
  "title": "string",
  "owner": "string",
  "isAdmin": true,
  "isActive": true,
  "isNoComments": true,
  "isCommentOnly": true,
  "permission": "string",
  "color": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards

Create a board

This allows to create a board.

The color has to be chosen between belize, nephritis, pomegranate, pumpkin, wisteria, midnight:

Wekan logo

Body parameter

title: string
owner: string
isAdmin: true
isActive: true
isNoComments: true
isCommentOnly: true
permission: string
color: string

Parameters

Name In Type Required Description
body body object false none
» title body string true the new title of the board
» owner body string true "ABCDE12345" <= User ID in Wekan.
» isAdmin body boolean false is the owner an admin of the board (default true)
» isActive body boolean false is the board active (default true)
» isNoComments body boolean false disable comments (default false)
» isCommentOnly body boolean false only enable comments (default false)
» permission body string false "private" board <== Set to "public" if you
» color body string false the color of the board

Detailed descriptions

» owner: "ABCDE12345" <= User ID in Wekan. (Not username or email)

» permission: "private" board <== Set to "public" if you want public Wekan board

Example responses

200 Response

{
  "defaultSwimlaneId": "string",
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» defaultSwimlaneId string false none none
» _id string false none none

get_board

Code samples

# You can also use wget
curl -X GET /api/boards/{board} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}

Get the board with that particular ID

Parameters

Name In Type Required Description
board path string true the ID of the board to retrieve the data

Detailed descriptions

board: the ID of the board to retrieve the data

Example responses

200 Response

{
  "title": "string",
  "slug": "string",
  "archived": true,
  "createdAt": "string",
  "modifiedAt": "string",
  "stars": 0,
  "labels": [
    {
      "_id": "string",
      "name": "string",
      "color": "green"
    }
  ],
  "members": [
    {
      "userId": "string",
      "isAdmin": true,
      "isActive": true,
      "isNoComments": true,
      "isCommentOnly": true
    }
  ],
  "permission": "public",
  "color": "belize",
  "description": "string",
  "subtasksDefaultBoardId": "string",
  "subtasksDefaultListId": "string",
  "allowsSubtasks": true,
  "presentParentTask": "prefix-with-full-path",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "type": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Boards

delete_board

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board} \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board} HTTP/1.1

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: '/api/boards/{board}',
  method: 'delete',

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

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

const headers = {
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}', params={

}, headers = headers)

print r.json()

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

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

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

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

DELETE /api/boards/{board}

Delete a board

Parameters

Name In Type Required Description
board path string true the ID of the board

Detailed descriptions

board: the ID of the board

Responses

Status Meaning Description Schema
200 OK 200 response None

add_board_label

Code samples

# You can also use wget
curl -X PUT /api/boards/{board}/labels \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT /api/boards/{board}/labels HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/labels',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "label": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/labels',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put '/api/boards/{board}/labels',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/boards/{board}/labels', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/labels");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

PUT /api/boards/{board}/labels

Add a label to a board

If the board doesn't have the name/color label, this function adds the label to the board.

Body parameter

label: string

Parameters

Name In Type Required Description
board path string true the board
body body object false none
» label body string true the label value

Detailed descriptions

board: the board

Example responses

200 Response

"string"

Responses

Status Meaning Description Schema
200 OK 200 response string

set_board_member_permission

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/members/{member} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/members/{member} HTTP/1.1

Content-Type: multipart/form-data

var headers = {
  'Content-Type':'multipart/form-data',
  'Authorization':'API_KEY'

};

$.ajax({
  url: '/api/boards/{board}/members/{member}',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "isAdmin": true,
  "isNoComments": true,
  "isCommentOnly": true
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/members/{member}',
{
  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' => 'multipart/form-data',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/members/{member}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'multipart/form-data',
  'Authorization': 'API_KEY'
}

r = requests.post('/api/boards/{board}/members/{member}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/members/{member}");
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{"multipart/form-data"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/members/{member}

Change the permission of a member of a board

Body parameter

isAdmin: true
isNoComments: true
isCommentOnly: true

Parameters

Name In Type Required Description
board path string true the ID of the board that we are changing
member path string true the ID of the user to change permissions
body body object false none
» isAdmin body boolean true admin capability
» isNoComments body boolean true NoComments capability
» isCommentOnly body boolean true CommentsOnly capability

Detailed descriptions

board: the ID of the board that we are changing

member: the ID of the user to change permissions

Responses

Status Meaning Description Schema
200 OK 200 response None

get_boards_from_user

Code samples

# You can also use wget
curl -X GET /api/users/{user}/boards \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/users/{user}/boards HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/users/{user}/boards',
  method: 'get',

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

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

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

};

fetch('/api/users/{user}/boards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/users/{user}/boards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/users/{user}/boards', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/users/{user}/boards

Get all boards attached to a user

Parameters

Name In Type Required Description
user path string true the ID of the user to retrieve the data

Detailed descriptions

user: the ID of the user to retrieve the data

Example responses

200 Response

[
  {
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

Checklists

get_all_checklists

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/cards/{card}/checklists HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/checklists',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/cards/{card}/checklists',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/cards/{card}/checklists', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/cards/{card}/checklists

Get the list of checklists attached to a card

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID

Detailed descriptions

board: the board ID

card: the card ID

Example responses

200 Response

[
  {
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

new_checklist

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/cards/{card}/checklists \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/cards/{card}/checklists HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/cards/{card}/checklists',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/cards/{card}/checklists',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/cards/{card}/checklists', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/cards/{card}/checklists

create a new checklist

Body parameter

title: string

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
body body object false none
» title body string true the title of the new checklist

Detailed descriptions

board: the board ID

card: the card ID

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_checklist

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists/{checklist}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/cards/{card}/checklists/{checklist}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/cards/{card}/checklists/{checklist}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/checklists/{checklist}", data)
    req.Header = headers

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

GET /api/boards/{board}/cards/{card}/checklists/{checklist}

Get a checklist

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
checklist path string true the ID of the checklist

Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist

Example responses

200 Response

{
  "cardId": "string",
  "title": "string",
  "finishedAt": "string",
  "createdAt": "string",
  "items": [
    {
      "title": "string",
      "_id": "string",
      "isFinished": true
    }
  ],
  "sort": 0
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» cardId string false none none
» title string false none none
» finishedAt string false none none
» createdAt string false none none
» items [object] false none none
»» title string false none none
»» _id string false none none
»» isFinished boolean false none none
» sort number false none none

delete_checklist

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists/{checklist}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/cards/{card}/checklists/{checklist}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/cards/{card}/checklists/{checklist}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/checklists/{checklist}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}

Delete a checklist

The checklist will be removed, not put in the recycle bin.

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
checklist path string true the ID of the checklist to remove

Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist to remove

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

ChecklistItems

get_checklist_item

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
    req.Header = headers

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

GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}

Get a checklist item

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
checklist path string true the checklist ID
item path string true the ID of the item

Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item

Example responses

200 Response

{
  "title": "string",
  "sort": 0,
  "isFinished": true,
  "checklistId": "string",
  "cardId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response ChecklistItems

edit_checklist_item

Code samples

# You can also use wget
curl -X PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "isFinished": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
    req.Header = headers

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

PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}

Edit a checklist item

Body parameter

isFinished: string
title: string

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
checklist path string true the checklist ID
item path string true the ID of the item
body body object false none
» isFinished body string false is the item checked?
» title body string false the new text of the item

Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

delete_checklist_item

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}

Delete a checklist item

Note: this operation can't be reverted.

Parameters

Name In Type Required Description
board path string true the board ID
card path string true the card ID
checklist path string true the checklist ID
item path string true the ID of the item to be removed

Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item to be removed

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

CardComments

get_all_comments

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/comments \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/cards/{card}/comments HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/comments',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/comments',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/cards/{card}/comments',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/cards/{card}/comments', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/comments");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/cards/{card}/comments

Get all comments attached to a card

Parameters

Name In Type Required Description
board path string true the board ID of the card
card path string true the ID of the card

Detailed descriptions

board: the board ID of the card

card: the ID of the card

Example responses

200 Response

[
  {
    "authorId": "string",
    "_id": "string",
    "comment": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» authorId string false none none
» _id string false none none
» comment string false none none

new_comment

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/cards/{card}/comments \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/cards/{card}/comments HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/comments',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "authorId": "string",
  "comment": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/cards/{card}/comments',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/cards/{card}/comments',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/cards/{card}/comments', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/comments");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/cards/{card}/comments

Add a comment on a card

Body parameter

authorId: string
comment: string

Parameters

Name In Type Required Description
board path string true the board ID of the card
card path string true the ID of the card
body body object false none
» authorId body string true the user who 'posted' the comment
» comment body string true the comment value

Detailed descriptions

board: the board ID of the card

card: the ID of the card

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_comment

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/comments/{comment} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/comments/{comment}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/cards/{card}/comments/{comment}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/cards/{card}/comments/{comment}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/comments/{comment}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/comments/{comment}", data)
    req.Header = headers

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

GET /api/boards/{board}/cards/{card}/comments/{comment}

Get a comment on a card

Parameters

Name In Type Required Description
board path string true the board ID of the card
card path string true the ID of the card
comment path string true the ID of the comment to retrieve

Detailed descriptions

board: the board ID of the card

card: the ID of the card

comment: the ID of the comment to retrieve

Example responses

200 Response

{
  "boardId": "string",
  "cardId": "string",
  "text": "string",
  "createdAt": "string",
  "userId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response CardComments

delete_comment

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/comments/{comment} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards/{card}/comments/{comment}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/cards/{card}/comments/{comment}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/cards/{card}/comments/{comment}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/comments/{comment}");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/comments/{comment}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/cards/{card}/comments/{comment}

Delete a comment on a card

Parameters

Name In Type Required Description
board path string true the board ID of the card
card path string true the ID of the card
comment path string true the ID of the comment to delete

Detailed descriptions

board: the board ID of the card

card: the ID of the card

comment: the ID of the comment to delete

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

CustomFields

get_all_custom_fields

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/custom-fields \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/custom-fields HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/custom-fields',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/custom-fields',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/custom-fields',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/custom-fields', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/custom-fields

Get the list of Custom Fields attached to a board

Parameters

Name In Type Required Description
board path string true the board value

Example responses

200 Response

[
  {
    "type": "string",
    "_id": "string",
    "name": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» type string false none none
» _id string false none none
» name string false none none

new_custom_field

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/custom-fields \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/custom-fields HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/custom-fields',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "type": "string",
  "settings": "string",
  "showOnCard": true,
  "automaticallyOnCard": true,
  "showLabelOnMiniCard": true,
  "authorId": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/custom-fields',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/custom-fields',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/custom-fields', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/custom-fields

Create a Custom Field

Body parameter

name: string
type: string
settings: string
showOnCard: true
automaticallyOnCard: true
showLabelOnMiniCard: true
authorId: string

Parameters

Name In Type Required Description
board path string true the board value
body body object false none
» name body string true the name of the custom field
» type body string true the type of the custom field
» settings body string true the settings object of the custom field
» showOnCard body boolean true should we show the custom field on cards?
» automaticallyOnCard body boolean true should the custom fields automatically be added on cards?
» showLabelOnMiniCard body boolean true should the label of the custom field be shown on minicards?
» authorId body string true the authorId value

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_custom_field

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/custom-fields/{customField} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/custom-fields/{customField} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/custom-fields/{customField}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/custom-fields/{customField}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/custom-fields/{customField}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/custom-fields/{customField}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields/{customField}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/boards/{board}/custom-fields/{customField}", data)
    req.Header = headers

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

GET /api/boards/{board}/custom-fields/{customField}

Get a Custom Fields attached to a board

Parameters

Name In Type Required Description
board path string true the board value
customField path string true the ID of the custom field

Detailed descriptions

customField: the ID of the custom field

Example responses

200 Response

{
  "boardIds": [
    "string"
  ],
  "name": "string",
  "type": "text",
  "settings": {
    "dropdownItems": [
      {}
    ]
  },
  "showOnCard": true,
  "automaticallyOnCard": true,
  "showLabelOnMiniCard": true
}

Responses

Status Meaning Description Schema
200 OK 200 response CustomFields

delete_custom_field

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/custom-fields/{customField} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/custom-fields/{customField} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/custom-fields/{customField}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/custom-fields/{customField}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/custom-fields/{customField}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/custom-fields/{customField}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields/{customField}");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/custom-fields/{customField}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/custom-fields/{customField}

Delete a Custom Fields attached to a board

The Custom Field can't be retrieved after this operation

Parameters

Name In Type Required Description
board path string true the board value
customField path string true the ID of the custom field

Detailed descriptions

customField: the ID of the custom field

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

Integrations

get_all_integrations

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/integrations \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/integrations HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/integrations',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/integrations',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/integrations', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/integrations

Get all integrations in board

Parameters

Name In Type Required Description
board path string true the board ID

Detailed descriptions

board: the board ID

Example responses

200 Response

[
  {
    "enabled": true,
    "title": "string",
    "type": "string",
    "activities": [
      "string"
    ],
    "url": "string",
    "token": "string",
    "boardId": "string",
    "createdAt": "string",
    "userId": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Integrations] false none [Integration with third-party applications]
» enabled boolean true none is the integration enabled?
» title string|null false none name of the integration
» type string true none type of the integratation (Default to 'outgoing-webhooks')
» activities [string] true none activities the integration gets triggered (list)
» url string true none URL validation regex (https://mathiasbynens.be/demo/url-regex)
» token string|null false none token of the integration
» boardId string true none Board ID of the integration
» createdAt string true none Creation date of the integration
» userId string true none user ID who created the interation

new_integration

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/integrations \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/integrations HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "url": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/integrations',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/integrations',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/integrations', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/integrations");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/integrations

Create a new integration

Body parameter

url: string

Parameters

Name In Type Required Description
board path string true the board ID
body body object false none
» url body string true the URL of the integration

Detailed descriptions

board: the board ID

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_integration

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/integrations/{int} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/integrations/{int} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations/{int}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/integrations/{int}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/integrations/{int}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/integrations/{int}', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/integrations/{int}

Get a single integration in board

Parameters

Name In Type Required Description
board path string true the board ID
int path string true the integration ID

Detailed descriptions

board: the board ID

int: the integration ID

Example responses

200 Response

{
  "enabled": true,
  "title": "string",
  "type": "string",
  "activities": [
    "string"
  ],
  "url": "string",
  "token": "string",
  "boardId": "string",
  "createdAt": "string",
  "userId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Integrations

edit_integration

Code samples

# You can also use wget
curl -X PUT /api/boards/{board}/integrations/{int} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT /api/boards/{board}/integrations/{int} HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations/{int}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "enabled": "string",
  "title": "string",
  "url": "string",
  "token": "string",
  "activities": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/integrations/{int}',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put '/api/boards/{board}/integrations/{int}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/boards/{board}/integrations/{int}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/integrations/{int}");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

PUT /api/boards/{board}/integrations/{int}

Edit integration data

Body parameter

enabled: string
title: string
url: string
token: string
activities: string

Parameters

Name In Type Required Description
board path string true the board ID
int path string true the integration ID
body body object false none
» enabled body string false is the integration enabled?
» title body string false new name of the integration
» url body string false new URL of the integration
» token body string false new token of the integration
» activities body string false new list of activities of the integration

Detailed descriptions

board: the board ID

int: the integration ID

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

delete_integration

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/integrations/{int} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/integrations/{int} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations/{int}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/integrations/{int}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/integrations/{int}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/integrations/{int}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/integrations/{int}");
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() {

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

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

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

DELETE /api/boards/{board}/integrations/{int}

Delete integration

Parameters

Name In Type Required Description
board path string true the board ID
int path string true the integration ID

Detailed descriptions

board: the board ID

int: the integration ID

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

delete_integration_activities

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/integrations/{int}/activities \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/integrations/{int}/activities HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations/{int}/activities',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/integrations/{int}/activities',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/integrations/{int}/activities',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/integrations/{int}/activities', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/integrations/{int}/activities");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/integrations/{int}/activities", data)
    req.Header = headers

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

DELETE /api/boards/{board}/integrations/{int}/activities

Delete subscribed activities

Parameters

Name In Type Required Description
board path string true the board ID
int path string true the integration ID

Detailed descriptions

board: the board ID

int: the integration ID

Example responses

200 Response

{
  "enabled": true,
  "title": "string",
  "type": "string",
  "activities": [
    "string"
  ],
  "url": "string",
  "token": "string",
  "boardId": "string",
  "createdAt": "string",
  "userId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Integrations

new_integration_activities

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/integrations/{int}/activities \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/integrations/{int}/activities HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/integrations/{int}/activities',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "activities": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/integrations/{int}/activities',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/integrations/{int}/activities',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/integrations/{int}/activities', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/integrations/{int}/activities");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/integrations/{int}/activities

Add subscribed activities

Body parameter

activities: string

Parameters

Name In Type Required Description
board path string true the board ID
int path string true the integration ID
body body object false none
» activities body string true the activities value

Detailed descriptions

board: the board ID

int: the integration ID

Example responses

200 Response

{
  "enabled": true,
  "title": "string",
  "type": "string",
  "activities": [
    "string"
  ],
  "url": "string",
  "token": "string",
  "boardId": "string",
  "createdAt": "string",
  "userId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Integrations

Lists

get_all_lists

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/lists \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/lists HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/lists',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/lists',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/lists', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/lists

Get the list of Lists attached to a board

Parameters

Name In Type Required Description
board path string true the board ID

Detailed descriptions

board: the board ID

Example responses

200 Response

[
  {
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

new_list

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/lists \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/lists HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/lists',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/lists',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/lists', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/lists

Add a List to a board

Body parameter

title: string

Parameters

Name In Type Required Description
board path string true the board ID
body body object false none
» title body string true the title of the List

Detailed descriptions

board: the board ID

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_list

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/lists/{list} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/lists/{list} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/lists/{list}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/lists/{list}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/lists/{list}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/lists/{list}

Get a List attached to a board

Parameters

Name In Type Required Description
board path string true the board ID
list path string true the List ID

Detailed descriptions

board: the board ID

list: the List ID

Example responses

200 Response

{
  "title": "string",
  "archived": true,
  "boardId": "string",
  "swimlaneId": "string",
  "createdAt": "string",
  "sort": 0,
  "updatedAt": "string",
  "wipLimit": {
    "value": 0,
    "enabled": true,
    "soft": true
  },
  "color": "white",
  "type": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Lists

delete_list

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/lists/{list} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/lists/{list} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/lists/{list}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/lists/{list}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/lists/{list}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}");
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() {

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

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

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

DELETE /api/boards/{board}/lists/{list}

Delete a List

This deletes a list from a board. The list is not put in the recycle bin.

Parameters

Name In Type Required Description
board path string true the board ID
list path string true the ID of the list to remove

Detailed descriptions

board: the board ID

list: the ID of the list to remove

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

Cards

get_all_cards

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/lists/{list}/cards \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/lists/{list}/cards HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/lists/{list}/cards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/lists/{list}/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/lists/{list}/cards', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/lists/{list}/cards

Get all Cards attached to a List

Parameters

Name In Type Required Description
board path string true the board ID
list path string true the list ID

Detailed descriptions

board: the board ID

list: the list ID

Example responses

200 Response

[
  {
    "description": "string",
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» description string false none none
» title string false none none
» _id string false none none

new_card

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/lists/{list}/cards \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/lists/{list}/cards HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "authorId": "string",
  "members": "string",
  "title": "string",
  "description": "string",
  "swimlaneId": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/lists/{list}/cards',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/lists/{list}/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/lists/{list}/cards', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/lists/{list}/cards

Create a new Card

Body parameter

authorId: string
members: string
title: string
description: string
swimlaneId: string

Parameters

Name In Type Required Description
board path string true the board ID of the new card
list path string true the list ID of the new card
body body object false none
» authorId body string true the authorId value
» members body string false the member IDs list of the new card
» title body string true the title of the new card
» description body string true the description of the new card
» swimlaneId body string true the swimlane ID of the new card

Detailed descriptions

board: the board ID of the new card

list: the list ID of the new card

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_card

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/lists/{list}/cards/{card} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards/{card}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/lists/{list}/cards/{card}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/lists/{list}/cards/{card}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/lists/{list}/cards/{card}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}/cards/{card}", data)
    req.Header = headers

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

GET /api/boards/{board}/lists/{list}/cards/{card}

Get a Card

Parameters

Name In Type Required Description
board path string true the board ID
list path string true the list ID of the card
card path string true the card ID

Detailed descriptions

board: the board ID

list: the list ID of the card

card: the card ID

Example responses

200 Response

{
  "title": "string",
  "archived": true,
  "parentId": "string",
  "listId": "string",
  "swimlaneId": "string",
  "boardId": "string",
  "coverId": "string",
  "color": "white",
  "createdAt": "string",
  "customFields": [
    {}
  ],
  "dateLastActivity": "string",
  "description": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "labelIds": [
    "string"
  ],
  "members": [
    "string"
  ],
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "userId": "string",
  "sort": 0,
  "subtaskSort": 0,
  "type": "string",
  "linkedId": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Cards

edit_card

Code samples

# You can also use wget
curl -X PUT /api/boards/{board}/lists/{list}/cards/{card} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards/{card}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "title": "string",
  "listId": "string",
  "authorId": "string",
  "parentId": "string",
  "description": "string",
  "color": "string",
  "labelIds": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": "string",
  "isOverTime": true,
  "customFields": "string",
  "members": "string",
  "swimlaneId": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/lists/{list}/cards/{card}',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.put '/api/boards/{board}/lists/{list}/cards/{card}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/boards/{board}/lists/{list}/cards/{card}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api/boards/{board}/lists/{list}/cards/{card}", data)
    req.Header = headers

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

PUT /api/boards/{board}/lists/{list}/cards/{card}

Edit Fields in a Card

Edit a card

The color has to be chosen between white, green, yellow, orange, red, purple, blue, sky, lime, pink, black, silver, peachpuff, crimson, plum, darkgreen, slateblue, magenta, gold, navy, gray, saddlebrown, paleturquoise, mistyrose, indigo:

Wekan card colors

Note: setting the color to white has the same effect than removing it.

Body parameter

title: string
listId: string
authorId: string
parentId: string
description: string
color: string
labelIds: string
requestedBy: string
assignedBy: string
receivedAt: string
startAt: string
dueAt: string
endAt: string
spentTime: string
isOverTime: true
customFields: string
members: string
swimlaneId: string

Parameters

Name In Type Required Description
board path string true the board ID of the card
list path string true the list ID of the card
card path string true the ID of the card
body body object false none
» title body string false the new title of the card
» listId body string false the new list ID of the card (move operation)
» authorId body string false change the owner of the card
» parentId body string false change the parent of the card
» description body string false the new description of the card
» color body string false the new color of the card
» labelIds body string false the new list of label IDs attached to the card
» requestedBy body string false the new requestedBy field of the card
» assignedBy body string false the new assignedBy field of the card
» receivedAt body string false the new receivedAt field of the card
» startAt body string false the new startAt field of the card
» dueAt body string false the new dueAt field of the card
» endAt body string false the new endAt field of the card
» spentTime body string false the new spentTime field of the card
» isOverTime body boolean false the new isOverTime field of the card
» customFields body string false the new customFields value of the card
» members body string false the new list of member IDs attached to the card
» swimlaneId body string false the new swimlane ID of the card

Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

delete_card

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/lists/{list}/cards/{card} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards/{card}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/lists/{list}/cards/{card}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/lists/{list}/cards/{card}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/lists/{list}/cards/{card}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
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() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api/boards/{board}/lists/{list}/cards/{card}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/lists/{list}/cards/{card}

Delete a card from a board

This operation deletes a card, and therefore the card is not put in the recycle bin.

Parameters

Name In Type Required Description
board path string true the board ID of the card
list path string true the list ID of the card
card path string true the ID of the card

Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_swimlane_cards

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/swimlanes/{swimlane}/cards \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/swimlanes/{swimlane}/cards HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/swimlanes/{swimlane}/cards',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/swimlanes/{swimlane}/cards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/swimlanes/{swimlane}/cards', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}/cards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/swimlanes/{swimlane}/cards

get all cards attached to a swimlane

Parameters

Name In Type Required Description
board path string true the board ID
swimlane path string true the swimlane ID

Detailed descriptions

board: the board ID

swimlane: the swimlane ID

Example responses

200 Response

[
  {
    "description": "string",
    "title": "string",
    "listId": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» description string false none none
» title string false none none
» listId string false none none
» _id string false none none

Users

add_board_member

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/members/{user}/add \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/members/{user}/add HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/members/{user}/add',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "action": "string",
  "isAdmin": true,
  "isNoComments": true,
  "isCommentOnly": true
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/members/{user}/add',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/members/{user}/add',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/members/{user}/add', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/members/{user}/add");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/members/{user}/add

Add New Board Member with Role

Only the admin user (the first user) can call the REST API.

Note: see Boards.set_board_member_permission to later change the permissions.

Body parameter

action: string
isAdmin: true
isNoComments: true
isCommentOnly: true

Parameters

Name In Type Required Description
board path string true the board ID
user path string true the user ID
body body object false none
» action body string true the action value
» isAdmin body boolean true is the user an admin of the board
» isNoComments body boolean true disable comments
» isCommentOnly body boolean true only enable comments

Detailed descriptions

board: the board ID

user: the user ID

Example responses

200 Response

{
  "title": "string",
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

remove_board_member

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/members/{user}/remove \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/members/{user}/remove HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/members/{user}/remove',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "action": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/members/{user}/remove',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/members/{user}/remove',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/members/{user}/remove', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/members/{user}/remove");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/members/{user}/remove

Remove Member from Board

Only the admin user (the first user) can call the REST API.

Body parameter

action: string

Parameters

Name In Type Required Description
board path string true the board ID
user path string true the user ID
body body object false none
» action body string true the action (needs to be remove)

Detailed descriptions

board: the board ID

user: the user ID

Example responses

200 Response

{
  "title": "string",
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

get_current_user

Code samples

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

GET /api/user HTTP/1.1

Accept: application/json

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

};

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

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

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

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

};

fetch('/api/user',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/user

returns the current user

Example responses

200 Response

{
  "username": "string",
  "emails": [
    {
      "address": "string",
      "verified": true
    }
  ],
  "createdAt": "string",
  "profile": {
    "avatarUrl": "string",
    "emailBuffer": [
      "string"
    ],
    "fullname": "string",
    "hiddenSystemMessages": true,
    "initials": "string",
    "invitedBoards": [
      "string"
    ],
    "language": "string",
    "notifications": [
      "string"
    ],
    "showCardsCountAt": 0,
    "starredBoards": [
      "string"
    ],
    "icode": "string",
    "boardView": "board-view-lists",
    "templatesBoardId": "string",
    "cardTemplatesSwimlaneId": "string",
    "listTemplatesSwimlaneId": "string",
    "boardTemplatesSwimlaneId": "string"
  },
  "services": {},
  "heartbeat": "string",
  "isAdmin": true,
  "createdThroughApi": true,
  "loginDisabled": true,
  "authenticationMethod": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Users

get_all_users

Code samples

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

GET /api/users HTTP/1.1

Accept: application/json

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

};

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

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

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

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

};

fetch('/api/users',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/users

return all the users

Only the admin user (the first user) can call the REST API.

Example responses

200 Response

[
  {
    "_id": "string",
    "username": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none
» username string false none none

new_user

Code samples

# You can also use wget
curl -X POST /api/users \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/users HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

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

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

const fetch = require('node-fetch');
const inputBody = '{
  "username": "string",
  "email": "string",
  "password": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/users',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

URL obj = new URL("/api/users");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/users

Create a new user

Only the admin user (the first user) can call the REST API.

Body parameter

username: string
email: string
password: string

Parameters

Name In Type Required Description
body body object false none
» username body string true the new username
» email body string true the email of the new user
» password body string true the password of the new user

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_user

Code samples

# You can also use wget
curl -X GET /api/users/{user} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/users/{user} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/users/{user}',
  method: 'get',

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

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

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

};

fetch('/api/users/{user}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('/api/users/{user}', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/users/{user}

get a given user

Only the admin user (the first user) can call the REST API.

Parameters

Name In Type Required Description
user path string true the user ID

Detailed descriptions

user: the user ID

Example responses

200 Response

{
  "username": "string",
  "emails": [
    {
      "address": "string",
      "verified": true
    }
  ],
  "createdAt": "string",
  "profile": {
    "avatarUrl": "string",
    "emailBuffer": [
      "string"
    ],
    "fullname": "string",
    "hiddenSystemMessages": true,
    "initials": "string",
    "invitedBoards": [
      "string"
    ],
    "language": "string",
    "notifications": [
      "string"
    ],
    "showCardsCountAt": 0,
    "starredBoards": [
      "string"
    ],
    "icode": "string",
    "boardView": "board-view-lists",
    "templatesBoardId": "string",
    "cardTemplatesSwimlaneId": "string",
    "listTemplatesSwimlaneId": "string",
    "boardTemplatesSwimlaneId": "string"
  },
  "services": {},
  "heartbeat": "string",
  "isAdmin": true,
  "createdThroughApi": true,
  "loginDisabled": true,
  "authenticationMethod": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Users

edit_user

Code samples

# You can also use wget
curl -X PUT /api/users/{user} \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

PUT /api/users/{user} HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/users/{user}',
  method: 'put',

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

const fetch = require('node-fetch');
const inputBody = '{
  "action": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

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

require 'rest-client'
require 'json'

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

result = RestClient.put '/api/users/{user}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('/api/users/{user}', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/users/{user}

edit a given user

Only the admin user (the first user) can call the REST API.

Possible values for action:

Body parameter

action: string

Parameters

Name In Type Required Description
user path string true the user ID
body body object false none
» action body string true the action

Detailed descriptions

user: the user ID

Example responses

200 Response

{
  "title": "string",
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

delete_user

Code samples

# You can also use wget
curl -X DELETE /api/users/{user} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/users/{user} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/users/{user}',
  method: 'delete',

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

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

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

};

fetch('/api/users/{user}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/users/{user}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/users/{user}', params={

}, headers = headers)

print r.json()

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

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

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

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

DELETE /api/users/{user}

Delete a user

Only the admin user (the first user) can call the REST API.

Parameters

Name In Type Required Description
user path string true the ID of the user to delete

Detailed descriptions

user: the ID of the user to delete

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

Swimlanes

get_all_swimlanes

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/swimlanes \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/swimlanes HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/swimlanes',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/swimlanes',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/swimlanes',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/swimlanes', params={

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/swimlanes

Get the list of swimlanes attached to a board

Parameters

Name In Type Required Description
board path string true the ID of the board

Detailed descriptions

board: the ID of the board

Example responses

200 Response

[
  {
    "title": "string",
    "_id": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» title string false none none
» _id string false none none

new_swimlane

Code samples

# You can also use wget
curl -X POST /api/boards/{board}/swimlanes \
  -H 'Content-Type: multipart/form-data' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

POST /api/boards/{board}/swimlanes HTTP/1.1

Content-Type: multipart/form-data
Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/swimlanes',
  method: 'post',

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

const fetch = require('node-fetch');
const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/swimlanes',
{
  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' => 'multipart/form-data',
  'Accept' => 'application/json',
  'Authorization' => 'API_KEY'
}

result = RestClient.post '/api/boards/{board}/swimlanes',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('/api/boards/{board}/swimlanes', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/swimlanes");
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{"multipart/form-data"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
        
    }

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

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

POST /api/boards/{board}/swimlanes

Add a swimlane to a board

Body parameter

title: string

Parameters

Name In Type Required Description
board path string true the ID of the board
body body object false none
» title body string true the new title of the swimlane

Detailed descriptions

board: the ID of the board

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

get_swimlane

Code samples

# You can also use wget
curl -X GET /api/boards/{board}/swimlanes/{swimlane} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

GET /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/swimlanes/{swimlane}',
  method: 'get',

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

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

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

};

fetch('/api/boards/{board}/swimlanes/{swimlane}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('/api/boards/{board}/swimlanes/{swimlane}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/swimlanes/{swimlane}

Get a swimlane

Parameters

Name In Type Required Description
board path string true the ID of the board
swimlane path string true the ID of the swimlane

Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane

Example responses

200 Response

{
  "title": "string",
  "archived": true,
  "boardId": "string",
  "createdAt": "string",
  "sort": 0,
  "color": "white",
  "updatedAt": "string",
  "type": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Swimlanes

delete_swimlane

Code samples

# You can also use wget
curl -X DELETE /api/boards/{board}/swimlanes/{swimlane} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

DELETE /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/swimlanes/{swimlane}',
  method: 'delete',

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

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

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

};

fetch('/api/boards/{board}/swimlanes/{swimlane}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete '/api/boards/{board}/swimlanes/{swimlane}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('/api/boards/{board}/swimlanes/{swimlane}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
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() {

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

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

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

DELETE /api/boards/{board}/swimlanes/{swimlane}

Delete a swimlane

The swimlane will be deleted, not moved to the recycle bin

Parameters

Name In Type Required Description
board path string true the ID of the board
swimlane path string true the ID of the swimlane

Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane

Example responses

200 Response

{
  "_id": "string"
}

Responses

Status Meaning Description Schema
200 OK 200 response Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» _id string false none none

Schemas

CustomFields

{
  "boardIds": [
    "string"
  ],
  "name": "string",
  "type": "text",
  "settings": {
    "dropdownItems": [
      {}
    ]
  },
  "showOnCard": true,
  "automaticallyOnCard": true,
  "showLabelOnMiniCard": true
}

A custom field on a card in the board

Properties

Name Type Required Restrictions Description
boardIds [string] true none the ID of the board
name string true none name of the custom field
type string true none type of the custom field
settings CustomFieldsSettings true none settings of the custom field
showOnCard boolean true none should we show on the cards this custom field
automaticallyOnCard boolean true none should the custom fields automatically be added on cards?
showLabelOnMiniCard boolean true none should the label of the custom field be shown on minicards?

Enumerated Values

Property Value
type text
type number
type date
type dropdown

CustomFieldsSettings

{
  "dropdownItems": [
    {}
  ]
}

Properties

Name Type Required Restrictions Description
dropdownItems [CustomFieldsSettingsDropdownitems] false none list of drop down items objects

CustomFieldsSettingsDropdownitems

{}

Properties

None

Users

{
  "username": "string",
  "emails": [
    {
      "address": "string",
      "verified": true
    }
  ],
  "createdAt": "string",
  "profile": {
    "avatarUrl": "string",
    "emailBuffer": [
      "string"
    ],
    "fullname": "string",
    "hiddenSystemMessages": true,
    "initials": "string",
    "invitedBoards": [
      "string"
    ],
    "language": "string",
    "notifications": [
      "string"
    ],
    "showCardsCountAt": 0,
    "starredBoards": [
      "string"
    ],
    "icode": "string",
    "boardView": "board-view-lists",
    "templatesBoardId": "string",
    "cardTemplatesSwimlaneId": "string",
    "listTemplatesSwimlaneId": "string",
    "boardTemplatesSwimlaneId": "string"
  },
  "services": {},
  "heartbeat": "string",
  "isAdmin": true,
  "createdThroughApi": true,
  "loginDisabled": true,
  "authenticationMethod": "string"
}

A User in wekan

Properties

Name Type Required Restrictions Description
username string|null false none the username of the user
emails [UsersEmails]|null false none the list of emails attached to a user
createdAt string true none creation date of the user
profile UsersProfile false none profile settings
services object|null false none services field of the user
heartbeat string|null false none last time the user has been seen
isAdmin boolean|null false none is the user an admin of the board?
createdThroughApi boolean|null false none was the user created through the API?
loginDisabled boolean|null false none loginDisabled field of the user
authenticationMethod string true none authentication method of the user

UsersEmails

{
  "address": "string",
  "verified": true
}

Properties

Name Type Required Restrictions Description
address string true none The email address
verified boolean true none Has the email been verified

UsersProfile

{
  "avatarUrl": "string",
  "emailBuffer": [
    "string"
  ],
  "fullname": "string",
  "hiddenSystemMessages": true,
  "initials": "string",
  "invitedBoards": [
    "string"
  ],
  "language": "string",
  "notifications": [
    "string"
  ],
  "showCardsCountAt": 0,
  "starredBoards": [
    "string"
  ],
  "icode": "string",
  "boardView": "board-view-lists",
  "templatesBoardId": "string",
  "cardTemplatesSwimlaneId": "string",
  "listTemplatesSwimlaneId": "string",
  "boardTemplatesSwimlaneId": "string"
}

Properties

Name Type Required Restrictions Description
avatarUrl string false none URL of the avatar of the user
emailBuffer [string] false none list of email buffers of the user
fullname string false none full name of the user
hiddenSystemMessages boolean false none does the user wants to hide system messages?
initials string false none initials of the user
invitedBoards [string] false none board IDs the user has been invited to
language string false none language of the user
notifications [string] false none enabled notifications for the user
showCardsCountAt number false none showCardCountAt field of the user
starredBoards [string] false none list of starred board IDs
icode string false none icode
boardView string false none boardView field of the user
templatesBoardId string true none Reference to the templates board
cardTemplatesSwimlaneId string true none Reference to the card templates swimlane Id
listTemplatesSwimlaneId string true none Reference to the list templates swimlane Id
boardTemplatesSwimlaneId string true none Reference to the board templates swimlane Id

Enumerated Values

Property Value
boardView board-view-lists
boardView board-view-swimlanes
boardView board-view-cal

Boards

{
  "title": "string",
  "slug": "string",
  "archived": true,
  "createdAt": "string",
  "modifiedAt": "string",
  "stars": 0,
  "labels": [
    {
      "_id": "string",
      "name": "string",
      "color": "green"
    }
  ],
  "members": [
    {
      "userId": "string",
      "isAdmin": true,
      "isActive": true,
      "isNoComments": true,
      "isCommentOnly": true
    }
  ],
  "permission": "public",
  "color": "belize",
  "description": "string",
  "subtasksDefaultBoardId": "string",
  "subtasksDefaultListId": "string",
  "allowsSubtasks": true,
  "presentParentTask": "prefix-with-full-path",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "type": "string"
}

This is a Board.

Properties

Name Type Required Restrictions Description
title string true none The title of the board
slug string true none The title slugified.
archived boolean true none Is the board archived?
createdAt string true none Creation time of the board
modifiedAt string|null false none Last modification time of the board
stars number true none How many stars the board has
labels [BoardsLabels] true none List of labels attached to a board
members [BoardsMembers] true none List of members of a board
permission string true none visibility of the board
color string true none The color of the board.
description string|null false none The description of the board
subtasksDefaultBoardId string|null false none The default board ID assigned to subtasks.
subtasksDefaultListId string|null false none The default List ID assigned to subtasks.
allowsSubtasks boolean true none Does the board allows subtasks?
presentParentTask string|null false none Controls how to present the parent task: - prefix-with-full-path: add a prefix with the full path - prefix-with-parent: add a prefisx with the parent name - subtext-with-full-path: add a subtext with the full path - subtext-with-parent: add a subtext with the parent name - no-parent: does not show the parent at all
startAt string|null false none Starting date of the board.
dueAt string|null false none Due date of the board.
endAt string|null false none End date of the board.
spentTime number|null false none Time spent in the board.
isOvertime boolean|null false none Is the board overtimed?
type string true none The type of board

Enumerated Values

Property Value
permission public
permission private
color belize
color nephritis
color pomegranate
color pumpkin
color wisteria
color midnight
presentParentTask prefix-with-full-path
presentParentTask prefix-with-parent
presentParentTask subtext-with-full-path
presentParentTask subtext-with-parent
presentParentTask no-parent

BoardsLabels

{
  "_id": "string",
  "name": "string",
  "color": "green"
}

Properties

Name Type Required Restrictions Description
_id string true none Unique id of a label
name string false none Name of a label
color string true none color of a label. Can be amongst green, yellow, orange, red, purple, blue, sky, lime, pink, black, silver, peachpuff, crimson, plum, darkgreen, slateblue, magenta, gold, navy, gray, saddlebrown, paleturquoise, mistyrose, indigo

Enumerated Values

Property Value
color green
color yellow
color orange
color red
color purple
color blue
color sky
color lime
color pink
color black
color silver
color peachpuff
color crimson
color plum
color darkgreen
color slateblue
color magenta
color gold
color navy
color gray
color saddlebrown
color paleturquoise
color mistyrose
color indigo

BoardsMembers

{
  "userId": "string",
  "isAdmin": true,
  "isActive": true,
  "isNoComments": true,
  "isCommentOnly": true
}

Properties

Name Type Required Restrictions Description
userId string true none The uniq ID of the member
isAdmin boolean true none Is the member an admin of the board?
isActive boolean true none Is the member active?
isNoComments boolean false none Is the member not allowed to make comments
isCommentOnly boolean false none Is the member only allowed to comment on the board

Cards

{
  "title": "string",
  "archived": true,
  "parentId": "string",
  "listId": "string",
  "swimlaneId": "string",
  "boardId": "string",
  "coverId": "string",
  "color": "white",
  "createdAt": "string",
  "customFields": [
    {}
  ],
  "dateLastActivity": "string",
  "description": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "labelIds": [
    "string"
  ],
  "members": [
    "string"
  ],
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "userId": "string",
  "sort": 0,
  "subtaskSort": 0,
  "type": "string",
  "linkedId": "string"
}

Properties

Name Type Required Restrictions Description
title string|null false none the title of the card
archived boolean true none is the card archived
parentId string|null false none ID of the parent card
listId string|null false none List ID where the card is
swimlaneId string true none Swimlane ID where the card is
boardId string|null false none Board ID of the card
coverId string|null false none Cover ID of the card
color string|null false none none
createdAt string true none creation date
customFields [CardsCustomfields]|null false none list of custom fields
dateLastActivity string true none Date of last activity
description string|null false none description of the card
requestedBy string|null false none who requested the card (ID of the user)
assignedBy string|null false none who assigned the card (ID of the user)
labelIds [string]|null false none list of labels ID the card has
members [string]|null false none list of members (user IDs)
receivedAt string|null false none Date the card was received
startAt string|null false none Date the card was started to be worked on
dueAt string|null false none Date the card is due
endAt string|null false none Date the card ended
spentTime number|null false none How much time has been spent on this
isOvertime boolean|null false none is the card over time?
userId string true none user ID of the author of the card
sort number true none Sort value
subtaskSort number|null false none subtask sort value
type string true none type of the card
linkedId string|null false none ID of the linked card

Enumerated Values

Property Value
color white
color green
color yellow
color orange
color red
color purple
color blue
color sky
color lime
color pink
color black
color silver
color peachpuff
color crimson
color plum
color darkgreen
color slateblue
color magenta
color gold
color navy
color gray
color saddlebrown
color paleturquoise
color mistyrose
color indigo

CardsCustomfields

{}

Properties

None

ChecklistItems

{
  "title": "string",
  "sort": 0,
  "isFinished": true,
  "checklistId": "string",
  "cardId": "string"
}

An item in a checklist

Properties

Name Type Required Restrictions Description
title string true none the text of the item
sort number true none the sorting field of the item
isFinished boolean true none Is the item checked?
checklistId string true none the checklist ID the item is attached to
cardId string true none the card ID the item is attached to

Checklists

{
  "cardId": "string",
  "title": "string",
  "finishedAt": "string",
  "createdAt": "string",
  "sort": 0
}

A Checklist

Properties

Name Type Required Restrictions Description
cardId string true none The ID of the card the checklist is in
title string true none the title of the checklist
finishedAt string|null false none When was the checklist finished
createdAt string true none Creation date of the checklist
sort number true none sorting value of the checklist

Integrations

{
  "enabled": true,
  "title": "string",
  "type": "string",
  "activities": [
    "string"
  ],
  "url": "string",
  "token": "string",
  "boardId": "string",
  "createdAt": "string",
  "userId": "string"
}

Integration with third-party applications

Properties

Name Type Required Restrictions Description
enabled boolean true none is the integration enabled?
title string|null false none name of the integration
type string true none type of the integratation (Default to 'outgoing-webhooks')
activities [string] true none activities the integration gets triggered (list)
url string true none URL validation regex (https://mathiasbynens.be/demo/url-regex)
token string|null false none token of the integration
boardId string true none Board ID of the integration
createdAt string true none Creation date of the integration
userId string true none user ID who created the interation

Swimlanes

{
  "title": "string",
  "archived": true,
  "boardId": "string",
  "createdAt": "string",
  "sort": 0,
  "color": "white",
  "updatedAt": "string",
  "type": "string"
}

A swimlane is an line in the kaban board.

Properties

Name Type Required Restrictions Description
title string true none the title of the swimlane
archived boolean true none is the swimlane archived?
boardId string true none the ID of the board the swimlane is attached to
createdAt string true none creation date of the swimlane
sort number|null false none the sort value of the swimlane
color string|null false none the color of the swimlane
updatedAt string|null false none when was the swimlane last edited
type string true none The type of swimlane

Enumerated Values

Property Value
color white
color green
color yellow
color orange
color red
color purple
color blue
color sky
color lime
color pink
color black
color peachpuff
color crimson
color plum
color darkgreen
color slateblue
color magenta
color gold
color navy
color gray
color saddlebrown
color paleturquoise
color mistyrose
color indigo

CardComments

{
  "boardId": "string",
  "cardId": "string",
  "text": "string",
  "createdAt": "string",
  "userId": "string"
}

A comment on a card

Properties

Name Type Required Restrictions Description
boardId string true none the board ID
cardId string true none the card ID
text string true none the text of the comment
createdAt string true none when was the comment created
userId string true none the author ID of the comment

Lists

{
  "title": "string",
  "archived": true,
  "boardId": "string",
  "swimlaneId": "string",
  "createdAt": "string",
  "sort": 0,
  "updatedAt": "string",
  "wipLimit": {
    "value": 0,
    "enabled": true,
    "soft": true
  },
  "color": "white",
  "type": "string"
}

A list (column) in the Wekan board.

Properties

Name Type Required Restrictions Description
title string true none the title of the list
archived boolean true none is the list archived
boardId string true none the board associated to this list
swimlaneId string true none the swimlane associated to this list. Used for templates
createdAt string true none creation date
sort number|null false none is the list sorted
updatedAt string|null false none last update of the list
wipLimit ListsWiplimit false none WIP object, see below
color string|null false none the color of the list
type string true none The type of list

Enumerated Values

Property Value
color white
color green
color yellow
color orange
color red
color purple
color blue
color sky
color lime
color pink
color black
color peachpuff
color crimson
color plum
color darkgreen
color slateblue
color magenta
color gold
color navy
color gray
color saddlebrown
color paleturquoise
color mistyrose
color indigo

ListsWiplimit

{
  "value": 0,
  "enabled": true,
  "soft": true
}

Properties

Name Type Required Restrictions Description
value number true none value of the WIP
enabled boolean true none is the WIP enabled
soft boolean true none is the WIP a soft or hard requirement