Wekan REST API v7.88

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:

• Only call via HTTPS
• Implement a timed authorization token expiration strategy
• Ensure the calling user only has permissions for what they are calling and no more

Authentication

• API Key (UserSecurity)
  • Parameter Name: Authorization, in: header.

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:

• You will need to provide the token for any of the authenticated methods.

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

exportJson

Code samples

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

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

var headers = {
  'Authorization':'API_KEY'

};

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

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

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

const headers = {
  'Authorization':'API_KEY'

};

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

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/boards/{board}/export

This route is used to export the board to a json file format.

If user is already logged-in, pass loginToken as param "authToken": '/api/boards/:boardId/export?authToken=:token'

See https://blog.kayla.com.au/server-side-route-authentication-in-meteor/ for detailed explanations

Parameters

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

Detailed descriptions

board: the ID of the board we are exporting

Responses

Status	Meaning	Description	Schema
200	OK	200 response	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

[
  {
    "_id": "string",
    "title": "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
» title	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",
  "items": "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
items: 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
» items	body	string	false	the list of items on 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",
  "sort": 0,
  "items": [
    {
      "_id": "string",
      "title": "string",
      "isFinished": true
    }
  ]
}

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
» sort	number	false	none	none
» items	[object]	false	none	none
»» _id	string	false	none	none
»» title	string	false	none	none
»» isFinished	boolean	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

new_checklist_item

Code samples

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

POST /api/boards/{board}/cards/{card}/checklists/{checklist}/items 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',
  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/{checklist}/items',
{
  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/{checklist}/items',
  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/{checklist}/items', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items");
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/{checklist}/items", data)
    req.Header = headers

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

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

add a new item to a 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
checklist	path	string	true	the ID of the checklist
body	body	object	false	none
» title	body	string	true	the title of the new item

Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist

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_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",
  "createdAt": "string",
  "modifiedAt": "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

[
  {
    "_id": "string",
    "comment": "string",
    "authorId": "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
» comment	string	false	none	none
» authorId	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",
  "modifiedAt": "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

Cards

get_cards_by_custom_field

Code samples

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

GET /api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue} HTTP/1.1

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}',
  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}/cardsByCustomField/{customField}/{customFieldValue}',
{
  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}/cardsByCustomField/{customField}/{customFieldValue}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}");
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}/cardsByCustomField/{customField}/{customFieldValue}", data)
    req.Header = headers

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

GET /api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}

Get all Cards that matchs a value of a specific custom field

Parameters

Name	In	Type	Required	Description
board	path	string	true	the board ID
customField	path	string	true	the list ID
customFieldValue	path	string	true	the value to look for

Detailed descriptions

board: the board ID

customField: the list ID

customFieldValue: the value to look for

Example responses

200 Response

[
  {
    "_id": "string",
    "title": "string",
    "description": "string",
    "listId": "string",
    "swinlaneId": "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
» title	string	false	none	none
» description	string	false	none	none
» listId	string	false	none	none
» swinlaneId	string	false	none	none

get_board_cards_count

Code samples

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

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

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/cards_count',
  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_count',
{
  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_count',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/cards_count");
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_count", data)
    req.Header = headers

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

GET /api/boards/{board}/cards_count

Get a cards count 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

{
  "board_cards_count": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	200 response	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
» board_cards_count	integer	false	none	none

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

[
  {
    "_id": "string",
    "title": "string",
    "description": "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
» title	string	false	none	none
» description	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",
  "assignees": "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
assignees: 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
» assignees	body	string	false	the assignee 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,
  "archivedAt": "string",
  "parentId": "string",
  "listId": "string",
  "swimlaneId": "string",
  "boardId": "string",
  "coverId": "string",
  "color": "white",
  "createdAt": "string",
  "modifiedAt": "string",
  "customFields": [
    {}
  ],
  "dateLastActivity": "string",
  "description": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "labelIds": [
    "string"
  ],
  "members": [
    "string"
  ],
  "assignees": [
    "string"
  ],
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "userId": "string",
  "sort": 0,
  "subtaskSort": 0,
  "type": "string",
  "linkedId": "string",
  "vote": {
    "question": "string",
    "positive": [
      "string"
    ],
    "negative": [
      "string"
    ],
    "end": "string",
    "public": true,
    "allowNonBoardMembers": true
  },
  "poker": {
    "question": true,
    "one": [
      "string"
    ],
    "two": [
      "string"
    ],
    "three": [
      "string"
    ],
    "five": [
      "string"
    ],
    "eight": [
      "string"
    ],
    "thirteen": [
      "string"
    ],
    "twenty": [
      "string"
    ],
    "forty": [
      "string"
    ],
    "oneHundred": [
      "string"
    ],
    "unsure": [
      "string"
    ],
    "end": "string",
    "allowNonBoardMembers": true,
    "estimation": 0
  },
  "targetId_gantt": [
    "string"
  ],
  "linkType_gantt": [
    0
  ],
  "linkId_gantt": [
    "string"
  ],
  "cardNumber": 0,
  "showActivities": true,
  "hideFinishedChecklistIfItemsAreHidden": true
}

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 = '{
  "newBoardId": "string",
  "newSwimlaneId": "string",
  "newListId": "string",
  "title": "string",
  "sort": "string",
  "parentId": "string",
  "description": "string",
  "color": "string",
  "vote": {},
  "poker": {},
  "labelIds": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": "string",
  "isOverTime": true,
  "customFields": "string",
  "members": "string",
  "assignees": "string",
  "swimlaneId": "string",
  "listId": "string",
  "authorId": "string",
  "archive": "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:

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

Body parameter

newBoardId: string
newSwimlaneId: string
newListId: string
title: string
sort: string
parentId: string
description: string
color: string
vote: {}
poker: {}
labelIds: string
requestedBy: string
assignedBy: string
receivedAt: string
startAt: string
dueAt: string
endAt: string
spentTime: string
isOverTime: true
customFields: string
members: string
assignees: string
swimlaneId: string
listId: string
authorId: string
archive: 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
» newBoardId	body	string	true	the newBoardId value
» newSwimlaneId	body	string	true	the newSwimlaneId value
» newListId	body	string	true	the newListId value
» title	body	string	false	the new title of the card
» sort	body	string	false	the new sort value 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
» vote	body	object	false	the vote object
» poker	body	object	false	the poker object
» 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
» assignees	body	string	false	the array of maximum one ID of assignee attached to the card
» swimlaneId	body	string	false	the new swimlane ID 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
» archive	body	string	true	the archive value

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

edit_card_custom_field

Code samples

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

POST /api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField} 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}/customFields/{customField}',
  method: 'post',

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

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

};

fetch('/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}',
{
  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/{card}/customFields/{customField}',
  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/{card}/customFields/{customField}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}");
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/{card}/customFields/{customField}", data)
    req.Header = headers

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

POST /api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}

Edit Custom Field in a Card

Edit a custom field value in a card

Body parameter

value: 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
customField	path	string	true	the ID of the custom field
body	body	object	false	none
» value	body	string	true	the new custom field value

Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

customField: the ID of the custom field

Example responses

200 Response

{
  "_id": "string",
  "customFields": {}
}

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	object	false	none	none

get_list_cards_count

Code samples

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

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

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/lists/{list}/cards_count',
  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_count',
{
  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_count',
  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_count', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/lists/{list}/cards_count");
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_count", data)
    req.Header = headers

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

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

Get a cards count 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

{
  "list_cards_count": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	200 response	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
» list_cards_count	integer	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

[
  {
    "_id": "string",
    "title": "string",
    "description": "string",
    "listId": "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
» title	string	false	none	none
» description	string	false	none	none
» listId	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

[
  {
    "_id": "string",
    "name": "string",
    "type": "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
» name	string	false	none	none
» type	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,
  "showSumAtTopOfList": 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
showSumAtTopOfList: 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?
» showSumAtTopOfList	body	boolean	true	should the sum of the custom fields be shown at top of list?
» 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

[
  {
    "_id": "string",
    "boardIds": "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
» boardIds	string	false	none	none

edit_custom_field

Code samples

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

PUT /api/boards/{board}/custom-fields/{customField} 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/{customField}',
  method: 'put',

  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,
  "alwaysOnCard": "string",
  "showLabelOnMiniCard": true,
  "showSumAtTopOfList": true
}';
const headers = {
  'Content-Type':'multipart/form-data',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('/api/boards/{board}/custom-fields/{customField}',
{
  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}/custom-fields/{customField}',
  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}/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("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}/custom-fields/{customField}", data)
    req.Header = headers

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

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

Update a Custom Field

Body parameter

name: string
type: string
settings: string
showOnCard: true
automaticallyOnCard: true
alwaysOnCard: string
showLabelOnMiniCard: true
showSumAtTopOfList: true

Parameters

Name	In	Type	Required	Description
board	path	string	true	the board value
customField	path	string	true	the customField 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
» alwaysOnCard	body	string	true	the alwaysOnCard value
» showLabelOnMiniCard	body	boolean	true	should the label of the custom field be shown on minicards
» showSumAtTopOfList	body	boolean	true	should the sum of the custom fields be shown at top of list

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_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

add_custom_field_dropdown_items

Code samples

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

POST /api/boards/{board}/custom-fields/{customField}/dropdown-items 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/{customField}/dropdown-items',
  method: 'post',

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

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

};

fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items',
{
  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/{customField}/dropdown-items',
  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/{customField}/dropdown-items', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items");
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/{customField}/dropdown-items", data)
    req.Header = headers

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

POST /api/boards/{board}/custom-fields/{customField}/dropdown-items

Update a Custom Field's dropdown items

Body parameter

items: string

Parameters

Name	In	Type	Required	Description
board	path	string	true	the board value
customField	path	string	true	the customField value
body	body	object	false	none
» items	body	string	false	names 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

edit_custom_field_dropdown_item

Code samples

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

PUT /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem} 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/{customField}/dropdown-items/{dropdownItem}',
  method: 'put',

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

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

};

fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
{
  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}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
  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}/custom-fields/{customField}/dropdown-items/{dropdownItem}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}");
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}/custom-fields/{customField}/dropdown-items/{dropdownItem}", data)
    req.Header = headers

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

PUT /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}

Update a Custom Field's dropdown item

Body parameter

name: string

Parameters

Name	In	Type	Required	Description
board	path	string	true	the board value
customField	path	string	true	the customField value
dropdownItem	path	string	true	the dropdownItem value
body	body	object	false	none
» name	body	string	true	names 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

delete_custom_field_dropdown_item

Code samples

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

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

Accept: application/json

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

};

$.ajax({
  url: '/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
  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}/dropdown-items/{dropdownItem}',
{
  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}/dropdown-items/{dropdownItem}',
  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}/dropdown-items/{dropdownItem}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}");
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}/dropdown-items/{dropdownItem}", data)
    req.Header = headers

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

DELETE /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}

Update a Custom Field's dropdown items

Parameters

Name	In	Type	Required	Description
board	path	string	true	the board value
customField	path	string	true	the customField value
dropdownItem	path	string	true	the dropdownItem 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

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",
    "modifiedAt": "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	none
» 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
» modifiedAt	string	true	none	none
» 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",
  "modifiedAt": "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",
  "modifiedAt": "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",
  "modifiedAt": "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

[
  {
    "_id": "string",
    "title": "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
» title	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",
  "starred": true,
  "archived": true,
  "archivedAt": "string",
  "boardId": "string",
  "swimlaneId": "string",
  "createdAt": "string",
  "sort": 0,
  "updatedAt": "string",
  "modifiedAt": "string",
  "wipLimit": {
    "value": 0,
    "enabled": true,
    "soft": true
  },
  "color": "white",
  "type": "string",
  "collapsed": true
}

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

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

[
  {
    "_id": "string",
    "title": "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
» title	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	new_swimlane	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,
  "archivedAt": "string",
  "boardId": "string",
  "createdAt": "string",
  "sort": 0,
  "color": "white",
  "updatedAt": "string",
  "modifiedAt": "string",
  "type": "string",
  "collapsed": true
}

Responses

Status	Meaning	Description	Schema
200	OK	200 response	Swimlanes

edit_swimlane

Code samples

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

PUT /api/boards/{board}/swimlanes/{swimlane} 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/{swimlane}',
  method: 'put',

  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/{swimlane}',
{
  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}/swimlanes/{swimlane}',
  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}/swimlanes/{swimlane}', params={

}, headers = headers)

print r.json()

URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
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}/swimlanes/{swimlane}", data)
    req.Header = headers

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

PUT /api/boards/{board}/swimlanes/{swimlane}

Edit the title of a swimlane

Body parameter

title: string

Parameters

Name	In	Type	Required	Description
board	path	string	true	the ID of the board
swimlane	path	string	true	the ID of the swimlane to edit
body	body	new_swimlane	false	none
» title	body	string	true	the new title of the swimlane

Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane to edit

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_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

CardComments

{
  "boardId": "string",
  "cardId": "string",
  "text": "string",
  "createdAt": "string",
  "modifiedAt": "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
modifiedAt	string	true	none	none
userId	string	true	none	the author ID of the comment

Cards

{
  "title": "string",
  "archived": true,
  "archivedAt": "string",
  "parentId": "string",
  "listId": "string",
  "swimlaneId": "string",
  "boardId": "string",
  "coverId": "string",
  "color": "white",
  "createdAt": "string",
  "modifiedAt": "string",
  "customFields": [
    {}
  ],
  "dateLastActivity": "string",
  "description": "string",
  "requestedBy": "string",
  "assignedBy": "string",
  "labelIds": [
    "string"
  ],
  "members": [
    "string"
  ],
  "assignees": [
    "string"
  ],
  "receivedAt": "string",
  "startAt": "string",
  "dueAt": "string",
  "endAt": "string",
  "spentTime": 0,
  "isOvertime": true,
  "userId": "string",
  "sort": 0,
  "subtaskSort": 0,
  "type": "string",
  "linkedId": "string",
  "vote": {
    "question": "string",
    "positive": [
      "string"
    ],
    "negative": [
      "string"
    ],
    "end": "string",
    "public": true,
    "allowNonBoardMembers": true
  },
  "poker": {
    "question": true,
    "one": [
      "string"
    ],
    "two": [
      "string"
    ],
    "three": [
      "string"
    ],
    "five": [
      "string"
    ],
    "eight": [
      "string"
    ],
    "thirteen": [
      "string"
    ],
    "twenty": [
      "string"
    ],
    "forty": [
      "string"
    ],
    "oneHundred": [
      "string"
    ],
    "unsure": [
      "string"
    ],
    "end": "string",
    "allowNonBoardMembers": true,
    "estimation": 0
  },
  "targetId_gantt": [
    "string"
  ],
  "linkType_gantt": [
    0
  ],
  "linkId_gantt": [
    "string"
  ],
  "cardNumber": 0,
  "showActivities": true,
  "hideFinishedChecklistIfItemsAreHidden": true
}

Properties

Name	Type	Required	Restrictions	Description
title	string|null	false	none	the title of the card
archived	boolean	true	none	is the card archived
archivedAt	string|null	false	none	latest archiving date
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
modifiedAt	string	true	none	none
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)
assignees	[string]|null	false	none	who is assignee of the card (user ID), maximum one ID of assignee in array.
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|null	false	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
vote	CardsVote	false	none	vote object, see below
poker	CardsPoker	false	none	poker object, see below
targetId_gantt	[string]|null	false	none	ID of card which is the child link in gantt view
linkType_gantt	[number]|null	false	none	ID of card which is the parent link in gantt view
linkId_gantt	[string]|null	false	none	ID of card which is the parent link in gantt view
cardNumber	number|null	false	none	A boardwise sequentially increasing number that is assigned to every newly created card
showActivities	boolean	true	none	none
hideFinishedChecklistIfItemsAreHidden	boolean|null	false	none	hide completed checklist?

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

CardsVote

{
  "question": "string",
  "positive": [
    "string"
  ],
  "negative": [
    "string"
  ],
  "end": "string",
  "public": true,
  "allowNonBoardMembers": true
}

Properties

Name	Type	Required	Restrictions	Description
question	string	true	none	none
positive	[string]	false	none	list of members (user IDs)
negative	[string]	false	none	list of members (user IDs)
end	string	false	none	none
public	boolean	true	none	none
allowNonBoardMembers	boolean	true	none	none

CardsPoker

{
  "question": true,
  "one": [
    "string"
  ],
  "two": [
    "string"
  ],
  "three": [
    "string"
  ],
  "five": [
    "string"
  ],
  "eight": [
    "string"
  ],
  "thirteen": [
    "string"
  ],
  "twenty": [
    "string"
  ],
  "forty": [
    "string"
  ],
  "oneHundred": [
    "string"
  ],
  "unsure": [
    "string"
  ],
  "end": "string",
  "allowNonBoardMembers": true,
  "estimation": 0
}

Properties

Name	Type	Required	Restrictions	Description
question	boolean	false	none	none
one	[string]	false	none	poker card one
two	[string]	false	none	poker card two
three	[string]	false	none	poker card three
five	[string]	false	none	poker card five
eight	[string]	false	none	poker card eight
thirteen	[string]	false	none	poker card thirteen
twenty	[string]	false	none	poker card twenty
forty	[string]	false	none	poker card forty
oneHundred	[string]	false	none	poker card oneHundred
unsure	[string]	false	none	poker card unsure
end	string	false	none	none
allowNonBoardMembers	boolean	false	none	none
estimation	number	false	none	poker estimation value

CardsCustomfields

{}

Properties

None

ChecklistItems

{
  "title": "string",
  "sort": 0,
  "isFinished": true,
  "checklistId": "string",
  "cardId": "string",
  "createdAt": "string",
  "modifiedAt": "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
createdAt	string|null	false	none	none
modifiedAt	string	true	none	none

Checklists

{
  "cardId": "string",
  "title": "string",
  "finishedAt": "string",
  "createdAt": "string",
  "modifiedAt": "string",
  "sort": 0,
  "hideCheckedChecklistItems": true,
  "hideAllChecklistItems": true
}

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
modifiedAt	string	true	none	none
sort	number	true	none	sorting value of the checklist
hideCheckedChecklistItems	boolean|null	false	none	hide the checked checklist-items?
hideAllChecklistItems	boolean|null	false	none	hide all checklist items ?

CustomFields

{
  "boardIds": [
    "string"
  ],
  "name": "string",
  "type": "text",
  "settings": {
    "currencyCode": "string",
    "dropdownItems": [
      {}
    ],
    "stringtemplateFormat": "string",
    "stringtemplateSeparator": "string"
  },
  "showOnCard": true,
  "automaticallyOnCard": true,
  "alwaysOnCard": true,
  "showLabelOnMiniCard": true,
  "showSumAtTopOfList": true,
  "createdAt": "string",
  "modifiedAt": "string"
}

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?
alwaysOnCard	boolean	true	none	should the custom field be automatically added to all cards?
showLabelOnMiniCard	boolean	true	none	should the label of the custom field be shown on minicards?
showSumAtTopOfList	boolean	true	none	should the sum of the custom fields be shown at top of list?
createdAt	string|null	false	none	none
modifiedAt	string	true	none	none

Enumerated Values

Property	Value
type	text
type	number
type	date
type	dropdown
type	checkbox
type	currency
type	stringtemplate

CustomFieldsSettings

{
  "currencyCode": "string",
  "dropdownItems": [
    {}
  ],
  "stringtemplateFormat": "string",
  "stringtemplateSeparator": "string"
}

Properties

Name	Type	Required	Restrictions	Description
currencyCode	string	false	none	none
dropdownItems	[CustomFieldsSettingsDropdownitems]	false	none	list of drop down items objects
stringtemplateFormat	string	false	none	none
stringtemplateSeparator	string	false	none	none

CustomFieldsSettingsDropdownitems

{}

Properties

None

Integrations

{
  "enabled": true,
  "title": "string",
  "type": "string",
  "activities": [
    "string"
  ],
  "url": "string",
  "token": "string",
  "boardId": "string",
  "createdAt": "string",
  "modifiedAt": "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	none
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
modifiedAt	string	true	none	none
userId	string	true	none	user ID who created the interation

Lists

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

A list (column) in the Wekan board.

Properties

Name	Type	Required	Restrictions	Description
title	string	true	none	the title of the list
starred	boolean|null	false	none	if a list is stared then we put it on the top
archived	boolean	true	none	is the list archived
archivedAt	string|null	false	none	latest archiving date
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
modifiedAt	string	true	none	none
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
collapsed	boolean	true	none	is the list collapsed

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

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

Swimlanes

{
  "title": "string",
  "archived": true,
  "archivedAt": "string",
  "boardId": "string",
  "createdAt": "string",
  "sort": 0,
  "color": "white",
  "updatedAt": "string",
  "modifiedAt": "string",
  "type": "string",
  "collapsed": true
}

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?
archivedAt	string|null	false	none	latest archiving date of the swimlane
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
modifiedAt	string	true	none	none
type	string	true	none	The type of swimlane
collapsed	boolean	true	none	is the swimlane collapsed

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