Wekan REST API v3.39
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 |
body | string | true | Your email |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Successful registration | Inline |
400 | Bad Request | Error in registration | Inline |
default | Default | Error in registration | None |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» id | string | false | none | none |
» token | string | false | none | none |
» tokenExpires | string | false | none | none |
Status Code 400
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» error | number | false | none | none |
» reason | string | false | none | none |
Boards
get_public_boards
Code samples
# You can also use wget
curl -X GET /api/boards \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/boards HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/boards', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/boards", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/boards
Get all public boards
Example responses
200 Response
[
{
"_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_board
Code samples
# You can also use wget
curl -X POST /api/boards \
-H 'Content-Type: multipart/form-data' \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
POST /api/boards HTTP/1.1
Content-Type: multipart/form-data
Accept: application/json
var headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"title": "string",
"owner": "string",
"isAdmin": true,
"isActive": true,
"isNoComments": true,
"isCommentOnly": true,
"permission": "string",
"color": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards
Create a board
This allows to create a board.
The color has to be chosen between belize
, nephritis
, pomegranate
,
pumpkin
, wisteria
, moderatepink
, strongcyan
,
limegreen
, midnight
, dark
, relax
, corteza
:
![Wekan logo](https://wekan.github.io/board-colors.png)
Body parameter
title: string
owner: string
isAdmin: true
isActive: true
isNoComments: true
isCommentOnly: true
permission: string
color: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
body | body | object | false | none |
» title | body | string | true | the new title of the board |
» owner | body | string | true | "ABCDE12345" <= User ID in Wekan. |
» isAdmin | body | boolean | false | is the owner an admin of the board (default true) |
» isActive | body | boolean | false | is the board active (default true) |
» isNoComments | body | boolean | false | disable comments (default false) |
» isCommentOnly | body | boolean | false | only enable comments (default false) |
» permission | body | string | false | "private" board <== Set to "public" if you |
» color | body | string | false | the color of the board |
Detailed descriptions
» owner: "ABCDE12345" <= User ID in Wekan. (Not username or email)
» permission: "private" board <== Set to "public" if you want public Wekan board
Example responses
200 Response
{
"_id": "string",
"defaultSwimlaneId": "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 |
» defaultSwimlaneId | string | false | none | none |
get_board
Code samples
# You can also use wget
curl -X GET /api/boards/{board} \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/boards/{board} HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/boards/{board}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/boards/{board}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/boards/{board}
Get the board with that particular ID
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the ID of the board to retrieve the data |
Detailed descriptions
board: the ID of the board to retrieve the data
Example responses
200 Response
{
"title": "string",
"slug": "string",
"archived": true,
"createdAt": "string",
"modifiedAt": "string",
"stars": 0,
"labels": [
{
"_id": "string",
"name": "string",
"color": "green"
}
],
"members": [
{
"userId": "string",
"isAdmin": true,
"isActive": true,
"isNoComments": true,
"isCommentOnly": true
}
],
"permission": "public",
"color": "belize",
"description": "string",
"subtasksDefaultBoardId": "string",
"subtasksDefaultListId": "string",
"allowsSubtasks": true,
"presentParentTask": "prefix-with-full-path",
"startAt": "string",
"dueAt": "string",
"endAt": "string",
"spentTime": 0,
"isOvertime": true,
"type": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Boards |
delete_board
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board} HTTP/1.1
var headers = {
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}',
method: 'delete',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Authorization': 'API_KEY'
}
r = requests.delete('/api/boards/{board}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "/api/boards/{board}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/boards/{board}
Delete a board
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the ID of the board |
Detailed descriptions
board: the ID of the board
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
export
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.
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 |
add_board_label
Code samples
# You can also use wget
curl -X PUT /api/boards/{board}/labels \
-H 'Content-Type: multipart/form-data' \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
PUT /api/boards/{board}/labels HTTP/1.1
Content-Type: multipart/form-data
Accept: application/json
var headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/labels',
method: 'put',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"label": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/labels',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.put '/api/boards/{board}/labels',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.put('/api/boards/{board}/labels', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/labels");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/api/boards/{board}/labels", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/boards/{board}/labels
Add a label to a board
If the board doesn't have the name/color label, this function adds the label to the board.
Body parameter
label: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board |
body | body | object | false | none |
» label | body | string | true | the label value |
Detailed descriptions
board: the board
Example responses
200 Response
"string"
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | string |
set_board_member_permission
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/members/{member} \
-H 'Content-Type: multipart/form-data' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/members/{member} HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/members/{member}',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"isAdmin": true,
"isNoComments": true,
"isCommentOnly": true
}';
const headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/members/{member}',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards/{board}/members/{member}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards/{board}/members/{member}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/members/{member}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards/{board}/members/{member}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards/{board}/members/{member}
Change the permission of a member of a board
Body parameter
isAdmin: true
isNoComments: true
isCommentOnly: true
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the ID of the board that we are changing |
member | path | string | true | the ID of the user to change permissions |
body | body | object | false | none |
» isAdmin | body | boolean | true | admin capability |
» isNoComments | body | boolean | true | NoComments capability |
» isCommentOnly | body | boolean | true | CommentsOnly capability |
Detailed descriptions
board: the ID of the board that we are changing
member: the ID of the user to change permissions
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
get_boards_from_user
Code samples
# You can also use wget
curl -X GET /api/users/{user}/boards \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/users/{user}/boards HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users/{user}/boards',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users/{user}/boards',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/users/{user}/boards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/users/{user}/boards', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users/{user}/boards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/users/{user}/boards", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/users/{user}/boards
Get all boards attached to a user
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
user | path | string | true | the ID of the user to retrieve the data |
Detailed descriptions
user: the ID of the user to retrieve the data
Example responses
200 Response
[
{
"_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 |
Checklists
get_board_card_checklists
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/cards/{card}/checklists HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/cards/{card}/checklists',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
post_board_card_checklists
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/cards/{card}/checklists \
-H 'Content-Type: multipart/form-data' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/cards/{card}/checklists HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/cards/{card}/checklists',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"title": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'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',
'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',
'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"},
"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
Body parameter
title: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
body | body | object | false | none |
» title | body | string | true | the title value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
get_board_card_checklist
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist} \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/cards/{card}/checklists/{checklist}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
checklist | path | string | true | the checklist value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
delete_board_card_checklist
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/cards/{card}/checklists/{checklist}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
checklist | path | string | true | the checklist value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
ChecklistItems
get_board_card_checklist_item
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1
var headers = {
'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 = {
'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 = {
'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 = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
checklist | path | string | true | the checklist value |
item | path | string | true | the item value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
put_board_card_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 'Authorization: API_KEY'
PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'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',
'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',
'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',
'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"},
"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}
Body parameter
isFinished: string
title: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
checklist | path | string | true | the checklist value |
item | path | string | true | the item value |
body | body | object | false | none |
» isFinished | body | string | true | the isFinished value |
» title | body | string | true | the title value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
delete_board_card_checklist_item
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1
var headers = {
'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 = {
'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 = {
'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 = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
checklist | path | string | true | the checklist value |
item | path | string | true | the item value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | 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 |
post_board_card_comments
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/cards/{card}/comments \
-H 'Content-Type: multipart/form-data' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/cards/{card}/comments HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'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',
'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',
'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',
'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"},
"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
Body parameter
authorId: string
comment: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
body | body | object | false | none |
» authorId | body | string | true | the authorId value |
» comment | body | string | true | the comment value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
get_board_card_comment
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/cards/{card}/comments/{comment} \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/cards/{card}/comments/{comment}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
comment | path | string | true | the comment value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
delete_board_card_comment
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/cards/{card}/comments/{comment} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/cards/{card}/comments/{comment}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
card | path | string | true | the card value |
comment | path | string | true | the comment value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | 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,
"authorId": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/custom-fields',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards/{board}/custom-fields',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards/{board}/custom-fields', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/custom-fields");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards/{board}/custom-fields", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards/{board}/custom-fields
Create a Custom Field
Body parameter
name: string
type: string
settings: string
showOnCard: true
automaticallyOnCard: true
showLabelOnMiniCard: true
authorId: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
body | body | object | false | none |
» name | body | string | true | the name of the custom field |
» type | body | string | true | the type of the custom field |
» settings | body | string | true | the settings object of the custom field |
» showOnCard | body | boolean | true | should we show the custom field on cards? |
» automaticallyOnCard | body | boolean | true | should the custom fields automatically be added on cards? |
» showLabelOnMiniCard | body | boolean | true | should the label of the custom field be shown on minicards? |
» authorId | body | string | true | the authorId value |
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
get_board_customField
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/custom-fields/{customField} \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/custom-fields/{customField} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/custom-fields/{customField}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
customField | path | string | true | the customField value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
delete_board_customField
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/custom-fields/{customField} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/custom-fields/{customField} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/custom-fields/{customField}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
customField | path | string | true | the customField value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | 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_board_int_activities
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/integrations/{int}/activities \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/integrations/{int}/activities HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/integrations/{int}/activities',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
int | path | string | true | the int value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
post_board_int_activities
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/integrations/{int}/activities \
-H 'Content-Type: multipart/form-data' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/integrations/{int}/activities HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'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',
'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',
'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',
'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"},
"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
Body parameter
activities: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
int | path | string | true | the int value |
body | body | object | false | none |
» activities | body | string | true | the activities value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
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",
"archived": true,
"boardId": "string",
"swimlaneId": "string",
"createdAt": "string",
"sort": 0,
"updatedAt": "string",
"modifiedAt": "string",
"wipLimit": {
"value": 0,
"enabled": true,
"soft": true
},
"color": "white",
"type": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Lists |
delete_list
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/lists/{list} \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/lists/{list} HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/lists/{list}',
method: 'delete',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/lists/{list}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/lists/{list}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.delete('/api/boards/{board}/lists/{list}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/lists/{list}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "/api/boards/{board}/lists/{list}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/boards/{board}/lists/{list}
Delete a List
This deletes a list from a board. The list is not put in the recycle bin.
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board ID |
list | path | string | true | the ID of the list to remove |
Detailed descriptions
board: the board ID
list: the ID of the list to remove
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
Cards
get_all_cards
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/lists/{list}/cards \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/lists/{list}/cards HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/lists/{list}/cards',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/lists/{list}/cards',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/lists/{list}/cards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/boards/{board}/lists/{list}/cards', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}/cards", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/boards/{board}/lists/{list}/cards
Get all Cards attached to a List
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board ID |
list | path | string | true | the list ID |
Detailed descriptions
board: the board ID
list: the list ID
Example responses
200 Response
[
{
"_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",
"title": "string",
"description": "string",
"swimlaneId": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/lists/{list}/cards',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards/{board}/lists/{list}/cards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards/{board}/lists/{list}/cards', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards/{board}/lists/{list}/cards", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards/{board}/lists/{list}/cards
Create a new Card
Body parameter
authorId: string
members: string
title: string
description: string
swimlaneId: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board ID of the new card |
list | path | string | true | the list ID of the new card |
body | body | object | false | none |
» authorId | body | string | true | the authorId value |
» members | body | string | false | the member IDs list of the new card |
» title | body | string | true | the title of the new card |
» description | body | string | true | the description of the new card |
» swimlaneId | body | string | true | the swimlane ID of the new card |
Detailed descriptions
board: the board ID of the new card
list: the list ID of the new card
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
get_board_list_card
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/lists/{list}/cards/{card} \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/lists/{list}/cards/{card}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
list | path | string | true | the list value |
card | path | string | true | the card value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
put_board_list_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 'Authorization: API_KEY'
PUT /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/lists/{list}/cards/{card}',
method: 'put',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"title": "string",
"listId": "string",
"authorId": "string",
"parentId": "string",
"description": "string",
"color": "string",
"labelIds": "string",
"requestedBy": "string",
"assignedBy": "string",
"receivedAt": "string",
"startAt": "string",
"dueAt": "string",
"endAt": "string",
"spentTime": "string",
"isOverTime": "string",
"customFields": "string",
"members": "string",
"swimlaneId": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'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',
'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',
'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"},
"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}
Body parameter
title: string
listId: string
authorId: string
parentId: string
description: string
color: string
labelIds: string
requestedBy: string
assignedBy: string
receivedAt: string
startAt: string
dueAt: string
endAt: string
spentTime: string
isOverTime: string
customFields: string
members: string
swimlaneId: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
list | path | string | true | the list value |
card | path | string | true | the card value |
body | body | object | false | none |
» title | body | string | true | the title value |
» listId | body | string | true | the listId value |
» authorId | body | string | true | the authorId value |
» parentId | body | string | true | the parentId value |
» description | body | string | true | the description value |
» color | body | string | true | the color value |
» labelIds | body | string | true | the labelIds value |
» requestedBy | body | string | true | the requestedBy value |
» assignedBy | body | string | true | the assignedBy value |
» receivedAt | body | string | true | the receivedAt value |
» startAt | body | string | true | the startAt value |
» dueAt | body | string | true | the dueAt value |
» endAt | body | string | true | the endAt value |
» spentTime | body | string | true | the spentTime value |
» isOverTime | body | string | true | the isOverTime value |
» customFields | body | string | true | the customFields value |
» members | body | string | true | the members value |
» swimlaneId | body | string | true | the swimlaneId value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
delete_board_list_card
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/lists/{list}/cards/{card} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/lists/{list}/cards/{card}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
list | path | string | true | the list value |
card | path | string | true | the card value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
get_board_swimlane_cards
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/swimlanes/{swimlane}/cards \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/swimlanes/{swimlane}/cards HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}/cards',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
swimlane | path | string | true | the swimlane value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
Users
add_board_member
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/members/{user}/add \
-H 'Content-Type: multipart/form-data' \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/members/{user}/add HTTP/1.1
Content-Type: multipart/form-data
Accept: application/json
var headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/members/{user}/add',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"action": "string",
"isAdmin": true,
"isNoComments": true,
"isCommentOnly": true
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/members/{user}/add',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards/{board}/members/{user}/add',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards/{board}/members/{user}/add', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/members/{user}/add");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards/{board}/members/{user}/add", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards/{board}/members/{user}/add
Add New Board Member with Role
Only the admin user (the first user) can call the REST API.
Note: see Boards.set_board_member_permission to later change the permissions.
Body parameter
action: string
isAdmin: true
isNoComments: true
isCommentOnly: true
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board ID |
user | path | string | true | the user ID |
body | body | object | false | none |
» action | body | string | true | the action value |
» isAdmin | body | boolean | true | is the user an admin of the board |
» isNoComments | body | boolean | true | disable comments |
» isCommentOnly | body | boolean | true | only enable comments |
Detailed descriptions
board: the board ID
user: the user ID
Example responses
200 Response
{
"_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 |
post_board_user_remove
Code samples
# You can also use wget
curl -X POST /api/boards/{board}/members/{user}/remove \
-H 'Content-Type: multipart/form-data' \
-H 'Authorization: API_KEY'
POST /api/boards/{board}/members/{user}/remove HTTP/1.1
Content-Type: multipart/form-data
var headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/members/{user}/remove',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"action": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/members/{user}/remove',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/boards/{board}/members/{user}/remove',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Authorization': 'API_KEY'
}
r = requests.post('/api/boards/{board}/members/{user}/remove', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/members/{user}/remove");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/boards/{board}/members/{user}/remove", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/boards/{board}/members/{user}/remove
Body parameter
action: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
user | path | string | true | the user value |
body | body | object | false | none |
» action | body | string | true | the action value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
get_current_user
Code samples
# You can also use wget
curl -X GET /api/user \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/user HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/user',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/user',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/user',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/user', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/user");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/user", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/user
returns the current user
Example responses
200 Response
{
"username": "string",
"emails": [
{
"address": "string",
"verified": true
}
],
"createdAt": "string",
"modifiedAt": "string",
"profile": {
"avatarUrl": "string",
"emailBuffer": [
"string"
],
"fullname": "string",
"hiddenSystemMessages": true,
"hiddenMinicardLabelText": true,
"initials": "string",
"invitedBoards": [
"string"
],
"language": "string",
"notifications": [
"string"
],
"showCardsCountAt": 0,
"starredBoards": [
"string"
],
"icode": "string",
"boardView": "board-view-lists",
"templatesBoardId": "string",
"cardTemplatesSwimlaneId": "string",
"listTemplatesSwimlaneId": "string",
"boardTemplatesSwimlaneId": "string"
},
"services": {},
"heartbeat": "string",
"isAdmin": true,
"createdThroughApi": true,
"loginDisabled": true,
"authenticationMethod": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Users |
get_all_users
Code samples
# You can also use wget
curl -X GET /api/users \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/users HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/users',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/users', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/users", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/users
return all the users
Only the admin user (the first user) can call the REST API.
Example responses
200 Response
[
{
"_id": "string",
"username": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
» username | string | false | none | none |
new_user
Code samples
# You can also use wget
curl -X POST /api/users \
-H 'Content-Type: multipart/form-data' \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
POST /api/users HTTP/1.1
Content-Type: multipart/form-data
Accept: application/json
var headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users',
method: 'post',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"username": "string",
"email": "string",
"password": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.post '/api/users',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.post('/api/users', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/api/users", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/users
Create a new user
Only the admin user (the first user) can call the REST API.
Body parameter
username: string
email: string
password: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
body | body | object | false | none |
» username | body | string | true | the new username |
body | string | true | the email of the new user | |
» password | body | string | true | the password of the new user |
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
get_user
Code samples
# You can also use wget
curl -X GET /api/users/{user} \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/users/{user} HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users/{user}',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users/{user}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/users/{user}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/users/{user}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users/{user}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/users/{user}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/users/{user}
get a given user
Only the admin user (the first user) can call the REST API.
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
user | path | string | true | the user ID |
Detailed descriptions
user: the user ID
Example responses
200 Response
{
"username": "string",
"emails": [
{
"address": "string",
"verified": true
}
],
"createdAt": "string",
"modifiedAt": "string",
"profile": {
"avatarUrl": "string",
"emailBuffer": [
"string"
],
"fullname": "string",
"hiddenSystemMessages": true,
"hiddenMinicardLabelText": true,
"initials": "string",
"invitedBoards": [
"string"
],
"language": "string",
"notifications": [
"string"
],
"showCardsCountAt": 0,
"starredBoards": [
"string"
],
"icode": "string",
"boardView": "board-view-lists",
"templatesBoardId": "string",
"cardTemplatesSwimlaneId": "string",
"listTemplatesSwimlaneId": "string",
"boardTemplatesSwimlaneId": "string"
},
"services": {},
"heartbeat": "string",
"isAdmin": true,
"createdThroughApi": true,
"loginDisabled": true,
"authenticationMethod": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Users |
edit_user
Code samples
# You can also use wget
curl -X PUT /api/users/{user} \
-H 'Content-Type: multipart/form-data' \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
PUT /api/users/{user} HTTP/1.1
Content-Type: multipart/form-data
Accept: application/json
var headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users/{user}',
method: 'put',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const inputBody = '{
"action": "string"
}';
const headers = {
'Content-Type':'multipart/form-data',
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users/{user}',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.put '/api/users/{user}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'multipart/form-data',
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.put('/api/users/{user}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users/{user}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"multipart/form-data"},
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/api/users/{user}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/users/{user}
edit a given user
Only the admin user (the first user) can call the REST API.
Possible values for action:
takeOwnership
: The admin takes the ownership of ALL boards of the user (archived and not archived) where the user is admin on.disableLogin
: Disable a user (the user is not allowed to login and his login tokens are purged)enableLogin
: Enable a user
Body parameter
action: string
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
user | path | string | true | the user ID |
body | body | object | false | none |
» action | body | string | true | the action |
Detailed descriptions
user: the user ID
Example responses
200 Response
{
"_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 |
delete_user
Code samples
# You can also use wget
curl -X DELETE /api/users/{user} \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
DELETE /api/users/{user} HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/users/{user}',
method: 'delete',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/users/{user}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/users/{user}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.delete('/api/users/{user}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/users/{user}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "/api/users/{user}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/users/{user}
Delete a user
Only the admin user (the first user) can call the REST API.
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
user | path | string | true | the ID of the user to delete |
Detailed descriptions
user: the ID of the user to delete
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
Swimlanes
get_all_swimlanes
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/swimlanes \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/swimlanes HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/swimlanes',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/swimlanes',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/swimlanes',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/boards/{board}/swimlanes', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/swimlanes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/boards/{board}/swimlanes", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/boards/{board}/swimlanes
Get the list of swimlanes attached to a board
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the ID of the board |
Detailed descriptions
board: the ID of the board
Example responses
200 Response
[
{
"_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 | object | false | none |
» title | body | string | true | the new title of the swimlane |
Detailed descriptions
board: the ID of the board
Example responses
200 Response
{
"_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Inline |
Response Schema
Status Code 200
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
» _id | string | false | none | none |
get_swimlane
Code samples
# You can also use wget
curl -X GET /api/boards/{board}/swimlanes/{swimlane} \
-H 'Accept: application/json' \
-H 'Authorization: API_KEY'
GET /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1
Accept: application/json
var headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
$.ajax({
url: '/api/boards/{board}/swimlanes/{swimlane}',
method: 'get',
headers: headers,
success: function(data) {
console.log(JSON.stringify(data));
}
})
const fetch = require('node-fetch');
const headers = {
'Accept':'application/json',
'Authorization':'API_KEY'
};
fetch('/api/boards/{board}/swimlanes/{swimlane}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'API_KEY'
}
result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'API_KEY'
}
r = requests.get('/api/boards/{board}/swimlanes/{swimlane}', params={
}, headers = headers)
print r.json()
URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"API_KEY"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/api/boards/{board}/swimlanes/{swimlane}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/boards/{board}/swimlanes/{swimlane}
Get a swimlane
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the ID of the board |
swimlane | path | string | true | the ID of the swimlane |
Detailed descriptions
board: the ID of the board
swimlane: the ID of the swimlane
Example responses
200 Response
{
"title": "string",
"archived": true,
"boardId": "string",
"createdAt": "string",
"sort": 0,
"color": "white",
"updatedAt": "string",
"modifiedAt": "string",
"type": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | Swimlanes |
delete_board_swimlane
Code samples
# You can also use wget
curl -X DELETE /api/boards/{board}/swimlanes/{swimlane} \
-H 'Authorization: API_KEY'
DELETE /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1
var headers = {
'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 = {
'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 = {
'Authorization' => 'API_KEY'
}
result = RestClient.delete '/api/boards/{board}/swimlanes/{swimlane}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'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{
"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}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
board | path | string | true | the board value |
swimlane | path | string | true | the swimlane value |
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | 200 response | None |
Schemas
Boards
{
"title": "string",
"slug": "string",
"archived": true,
"createdAt": "string",
"modifiedAt": "string",
"stars": 0,
"labels": [
{
"_id": "string",
"name": "string",
"color": "green"
}
],
"members": [
{
"userId": "string",
"isAdmin": true,
"isActive": true,
"isNoComments": true,
"isCommentOnly": true
}
],
"permission": "public",
"color": "belize",
"description": "string",
"subtasksDefaultBoardId": "string",
"subtasksDefaultListId": "string",
"allowsSubtasks": true,
"presentParentTask": "prefix-with-full-path",
"startAt": "string",
"dueAt": "string",
"endAt": "string",
"spentTime": 0,
"isOvertime": true,
"type": "string"
}
This is a Board.
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
title | string | true | none | The title of the board |
slug | string | true | none | The title slugified. |
archived | boolean | true | none | Is the board archived? |
createdAt | string | true | none | Creation time of the board |
modifiedAt | string|null | false | none | Last modification time of the board |
stars | number | true | none | How many stars the board has |
labels | [BoardsLabels] | true | none | List of labels attached to a board |
members | [BoardsMembers] | true | none | List of members of a board |
permission | string | true | none | visibility of the board |
color | string | true | none | The color of the board. |
description | string|null | false | none | The description of the board |
subtasksDefaultBoardId | string|null | false | none | The default board ID assigned to subtasks. |
subtasksDefaultListId | string|null | false | none | The default List ID assigned to subtasks. |
allowsSubtasks | boolean | true | none | Does the board allows subtasks? |
presentParentTask | string|null | false | none | Controls how to present the parent task: - prefix-with-full-path : add a prefix with the full path - prefix-with-parent : add a prefisx with the parent name - subtext-with-full-path : add a subtext with the full path - subtext-with-parent : add a subtext with the parent name - no-parent : does not show the parent at all |
startAt | string|null | false | none | Starting date of the board. |
dueAt | string|null | false | none | Due date of the board. |
endAt | string|null | false | none | End date of the board. |
spentTime | number|null | false | none | Time spent in the board. |
isOvertime | boolean|null | false | none | Is the board overtimed? |
type | string | true | none | The type of board |
Enumerated Values
Property | Value |
---|---|
permission | public |
permission | private |
color | belize |
color | nephritis |
color | pomegranate |
color | pumpkin |
color | wisteria |
color | moderatepink |
color | strongcyan |
color | limegreen |
color | midnight |
color | dark |
color | relax |
color | corteza |
presentParentTask | prefix-with-full-path |
presentParentTask | prefix-with-parent |
presentParentTask | subtext-with-full-path |
presentParentTask | subtext-with-parent |
presentParentTask | no-parent |
BoardsLabels
{
"_id": "string",
"name": "string",
"color": "green"
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
_id | string | true | none | Unique id of a label |
name | string | false | none | Name of a label |
color | string | true | none | color of a label. Can be amongst green , yellow , orange , red , purple , blue , sky , lime , pink , black , silver , peachpuff , crimson , plum , darkgreen , slateblue , magenta , gold , navy , gray , saddlebrown , paleturquoise , mistyrose , indigo |
Enumerated Values
Property | Value |
---|---|
color | green |
color | yellow |
color | orange |
color | red |
color | purple |
color | blue |
color | sky |
color | lime |
color | pink |
color | black |
color | silver |
color | peachpuff |
color | crimson |
color | plum |
color | darkgreen |
color | slateblue |
color | magenta |
color | gold |
color | navy |
color | gray |
color | saddlebrown |
color | paleturquoise |
color | mistyrose |
color | indigo |
BoardsMembers
{
"userId": "string",
"isAdmin": true,
"isActive": true,
"isNoComments": true,
"isCommentOnly": true
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
userId | string | true | none | The uniq ID of the member |
isAdmin | boolean | true | none | Is the member an admin of the board? |
isActive | boolean | true | none | Is the member active? |
isNoComments | boolean | false | none | Is the member not allowed to make comments |
isCommentOnly | boolean | false | none | Is the member only allowed to comment on the board |
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,
"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"
],
"receivedAt": "string",
"startAt": "string",
"dueAt": "string",
"endAt": "string",
"spentTime": 0,
"isOvertime": true,
"userId": "string",
"sort": 0,
"subtaskSort": 0,
"type": "string",
"linkedId": "string"
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
title | string|null | false | none | the title of the card |
archived | boolean | true | none | is the card archived |
parentId | string|null | false | none | ID of the parent card |
listId | string|null | false | none | List ID where the card is |
swimlaneId | string | true | none | Swimlane ID where the card is |
boardId | string|null | false | none | Board ID of the card |
coverId | string|null | false | none | Cover ID of the card |
color | string|null | false | none | none |
createdAt | string | true | none | creation date |
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) |
receivedAt | string|null | false | none | Date the card was received |
startAt | string|null | false | none | Date the card was started to be worked on |
dueAt | string|null | false | none | Date the card is due |
endAt | string|null | false | none | Date the card ended |
spentTime | number|null | false | none | How much time has been spent on this |
isOvertime | boolean|null | false | none | is the card over time? |
userId | string | true | none | user ID of the author of the card |
sort | number | true | none | Sort value |
subtaskSort | number|null | false | none | subtask sort value |
type | string | true | none | type of the card |
linkedId | string|null | false | none | ID of the linked card |
Enumerated Values
Property | Value |
---|---|
color | white |
color | green |
color | yellow |
color | orange |
color | red |
color | purple |
color | blue |
color | sky |
color | lime |
color | pink |
color | black |
color | silver |
color | peachpuff |
color | crimson |
color | plum |
color | darkgreen |
color | slateblue |
color | magenta |
color | gold |
color | navy |
color | gray |
color | saddlebrown |
color | paleturquoise |
color | mistyrose |
color | indigo |
CardsCustomfields
{}
Properties
None
ChecklistItems
{
"title": "string",
"sort": 0,
"isFinished": true,
"checklistId": "string",
"cardId": "string",
"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
}
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 |
CustomFields
{
"boardIds": [
"string"
],
"name": "string",
"type": "text",
"settings": {
"dropdownItems": [
{}
]
},
"showOnCard": true,
"automaticallyOnCard": true,
"showLabelOnMiniCard": 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? |
showLabelOnMiniCard | boolean | true | none | should the label of the custom field be shown on minicards? |
createdAt | string|null | false | none | none |
modifiedAt | string | true | none | none |
Enumerated Values
Property | Value |
---|---|
type | text |
type | number |
type | date |
type | dropdown |
CustomFieldsSettings
{
"dropdownItems": [
{}
]
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
dropdownItems | [CustomFieldsSettingsDropdownitems] | false | none | list of drop down items objects |
CustomFieldsSettingsDropdownitems
{}
Properties
None
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",
"archived": true,
"boardId": "string",
"swimlaneId": "string",
"createdAt": "string",
"sort": 0,
"updatedAt": "string",
"modifiedAt": "string",
"wipLimit": {
"value": 0,
"enabled": true,
"soft": true
},
"color": "white",
"type": "string"
}
A list (column) in the Wekan board.
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
title | string | true | none | the title of the list |
archived | boolean | true | none | is the list archived |
boardId | string | true | none | the board associated to this list |
swimlaneId | string | true | none | the swimlane associated to this list. Used for templates |
createdAt | string | true | none | creation date |
sort | number|null | false | none | is the list sorted |
updatedAt | string|null | false | none | last update of the list |
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 |
Enumerated Values
Property | Value |
---|---|
color | white |
color | green |
color | yellow |
color | orange |
color | red |
color | purple |
color | blue |
color | sky |
color | lime |
color | pink |
color | black |
color | peachpuff |
color | crimson |
color | plum |
color | darkgreen |
color | slateblue |
color | magenta |
color | gold |
color | navy |
color | gray |
color | saddlebrown |
color | paleturquoise |
color | mistyrose |
color | indigo |
ListsWiplimit
{
"value": 0,
"enabled": true,
"soft": true
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
value | number | true | none | value of the WIP |
enabled | boolean | true | none | is the WIP enabled |
soft | boolean | true | none | is the WIP a soft or hard requirement |
Swimlanes
{
"title": "string",
"archived": true,
"boardId": "string",
"createdAt": "string",
"sort": 0,
"color": "white",
"updatedAt": "string",
"modifiedAt": "string",
"type": "string"
}
A swimlane is an line in the kaban board.
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
title | string | true | none | the title of the swimlane |
archived | boolean | true | none | is the swimlane archived? |
boardId | string | true | none | the ID of the board the swimlane is attached to |
createdAt | string | true | none | creation date of the swimlane |
sort | number|null | false | none | the sort value of the swimlane |
color | string|null | false | none | the color of the swimlane |
updatedAt | string|null | false | none | when was the swimlane last edited |
modifiedAt | string | true | none | none |
type | string | true | none | The type of swimlane |
Enumerated Values
Property | Value |
---|---|
color | white |
color | green |
color | yellow |
color | orange |
color | red |
color | purple |
color | blue |
color | sky |
color | lime |
color | pink |
color | black |
color | peachpuff |
color | crimson |
color | plum |
color | darkgreen |
color | slateblue |
color | magenta |
color | gold |
color | navy |
color | gray |
color | saddlebrown |
color | paleturquoise |
color | mistyrose |
color | indigo |
Users
{
"username": "string",
"emails": [
{
"address": "string",
"verified": true
}
],
"createdAt": "string",
"modifiedAt": "string",
"profile": {
"avatarUrl": "string",
"emailBuffer": [
"string"
],
"fullname": "string",
"hiddenSystemMessages": true,
"hiddenMinicardLabelText": true,
"initials": "string",
"invitedBoards": [
"string"
],
"language": "string",
"notifications": [
"string"
],
"showCardsCountAt": 0,
"starredBoards": [
"string"
],
"icode": "string",
"boardView": "board-view-lists",
"templatesBoardId": "string",
"cardTemplatesSwimlaneId": "string",
"listTemplatesSwimlaneId": "string",
"boardTemplatesSwimlaneId": "string"
},
"services": {},
"heartbeat": "string",
"isAdmin": true,
"createdThroughApi": true,
"loginDisabled": true,
"authenticationMethod": "string"
}
A User in wekan
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
username | string|null | false | none | the username of the user |
emails | [UsersEmails]|null | false | none | the list of emails attached to a user |
createdAt | string | true | none | creation date of the user |
modifiedAt | string | true | none | none |
profile | UsersProfile | false | none | profile settings |
services | object|null | false | none | services field of the user |
heartbeat | string|null | false | none | last time the user has been seen |
isAdmin | boolean|null | false | none | is the user an admin of the board? |
createdThroughApi | boolean|null | false | none | was the user created through the API? |
loginDisabled | boolean|null | false | none | loginDisabled field of the user |
authenticationMethod | string | true | none | authentication method of the user |
UsersEmails
{
"address": "string",
"verified": true
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
address | string | true | none | The email address |
verified | boolean | true | none | Has the email been verified |
UsersProfile
{
"avatarUrl": "string",
"emailBuffer": [
"string"
],
"fullname": "string",
"hiddenSystemMessages": true,
"hiddenMinicardLabelText": true,
"initials": "string",
"invitedBoards": [
"string"
],
"language": "string",
"notifications": [
"string"
],
"showCardsCountAt": 0,
"starredBoards": [
"string"
],
"icode": "string",
"boardView": "board-view-lists",
"templatesBoardId": "string",
"cardTemplatesSwimlaneId": "string",
"listTemplatesSwimlaneId": "string",
"boardTemplatesSwimlaneId": "string"
}
Properties
Name | Type | Required | Restrictions | Description |
---|---|---|---|---|
avatarUrl | string | false | none | URL of the avatar of the user |
emailBuffer | [string] | false | none | list of email buffers of the user |
fullname | string | false | none | full name of the user |
hiddenSystemMessages | boolean | false | none | does the user want to hide system messages? |
hiddenMinicardLabelText | boolean | false | none | does the user want to hide minicard label texts? |
initials | string | false | none | initials of the user |
invitedBoards | [string] | false | none | board IDs the user has been invited to |
language | string | false | none | language of the user |
notifications | [string] | false | none | enabled notifications for the user |
showCardsCountAt | number | false | none | showCardCountAt field of the user |
starredBoards | [string] | false | none | list of starred board IDs |
icode | string | false | none | icode |
boardView | string | false | none | boardView field of the user |
templatesBoardId | string | true | none | Reference to the templates board |
cardTemplatesSwimlaneId | string | true | none | Reference to the card templates swimlane Id |
listTemplatesSwimlaneId | string | true | none | Reference to the list templates swimlane Id |
boardTemplatesSwimlaneId | string | true | none | Reference to the board templates swimlane Id |
Enumerated Values
Property | Value |
---|---|
boardView | board-view-lists |
boardView | board-view-swimlanes |
boardView | board-view-cal |