NAV undefined
undefined
ruby java javascript php python

Introduction

Our API was designed to help you integrate Yanado with 3rd party applications and consolidate your tasks and schedule within one application. Through the API we can help you seamlessly integrate with CRM, Support Desk, Monitoring apps and even robots (yes, one of the customers did just this).

We designed the Yanado API around REST principles.

Api Endpoint

All API calls must be made to https://api.yanado.com.

JSON-only

All responses will be in JSON. Input data passed through the request body can be form-encoded or JSON-encoded. If using a JSON body, please specify the Content-Type header as application/json.

In the API dates are represented as UNIX timestamps. Each entity like users or tasks has a unique ID.

Client Libraries

We have client libraries available in several languages. If you don’t see your language listed, you can generate it by yourself using Swagger. Please contact us and we would be happy to help.

If you need help using the API or need to discuss anything sensitive please message us at ares@yanado.com.

Authentication

The API uses HTTP Basic Authentication to authenticate users. A valid API key is required for all requests.

Use HTTPS only! Any HTTP requests will be ignored.

Obtaining an API Key

An API key can be obtained by signing in to Yanado.com, and then going to Settings > Integrations, then click on the plus button at the bottom right corner and generate a new API Key. Each user on Yanado has its own set of API keys. We recommend creating a separate API key for each application that will be making calls on your behalf.

Notifications

Get notifications

curl "api.yanado.com/public-api/notifications/{type}" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.NotificationsApi();
api.get_notifications(type, any_user, list_id);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.NotificationsApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
NotificationsApi api = new NotificationsApi(apiClient);
api.getNotifications(type, anyUser, listId);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\NotificationsApi($api_client);
$api->getNotifications(type, any_user, list_id);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getNotifications(type: mytype, anyUser: myanyUser, listId: mylistId, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::NotificationsApi.new

type = "type_example" # String | Notification type

opts = { 
  any_user: false, # BOOLEAN | Any user
  list_id: "list_id_example" # String | List id
}

begin
  #Get notifications
  result = api_instance.get_notifications(type, opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling NotificationsApi->get_notifications: #{e}"
end

The above command returns JSON structured like this:

[ {
  "assigneeId" : "str",
  "assigneeName" : "str",
  "created" : "2016-03-03T10:15:30.00Z",
  "id" : 1,
  "listId" : "str",
  "listName" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskCreated" : "2016-03-03T10:15:30.00Z",
  "taskDescription" : "str",
  "taskDueDate" : "2016-03-03T10:15:30.00Z",
  "taskHighPriority" : false,
  "taskId" : "str",
  "taskName" : "str",
  "userId" : "str",
  "userName" : "str"
} ]

HTTP Request

GET /public-api/notifications/{type}

Query Parameters

Parameter Required Type Description
anyUser false boolean Any user
listId false string List id

Path Parameters

Parameter Required Type Description
type true enum (ASSIGNEE, STATE, PRIORITY, DUEDATE, REMINDER, DETAILS) Notification type

Responses for status codes

200 403 500
Notification array

Email tasks

Get tasks with emails attached

curl "api.yanado.com/public-api/email-tasks" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.EmailtasksApi();
api.get_email_tasks(list_id, assignee, status_id, query);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.EmailtasksApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
EmailtasksApi api = new EmailtasksApi(apiClient);
api.getEmailTasks(listId, assignee, statusId, query);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\EmailtasksApi($api_client);
$api->getEmailTasks(list_id, assignee, status_id, query);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getEmailTasks(listId: mylistId, assignee: myassignee, statusId: mystatusId, query: myquery, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::EmailtasksApi.new

opts = { 
  list_id: "list_id_example", # String | List id
  assignee: "assignee_example", # String | Assignee
  status_id: "status_id_example", # String | Status Id
  query: "query_example" # String | Query
}

begin
  #Get tasks with emails attached
  result = api_instance.get_email_tasks(opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling EmailtasksApi->get_email_tasks: #{e}"
end

The above command returns JSON structured like this:

[ {
  "assigneeId" : "str",
  "assigneeName" : "str",
  "id" : 1,
  "listId" : "str",
  "listName" : "str",
  "participantEmail" : "str",
  "participantName" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "subject" : "str",
  "taskCreated" : "2016-03-03T10:15:30.00Z",
  "taskDescription" : "str",
  "taskDueDate" : "2016-03-03T10:15:30.00Z",
  "taskHighPriority" : false,
  "taskId" : "str",
  "taskName" : "str",
  "threadId" : "str"
} ]

HTTP Request

GET /public-api/email-tasks

Query Parameters

Parameter Required Type Description
listId false string List id
assignee false string Assignee
statusId false string Status Id
query false string Query

Responses for status codes

200 403 500
Email Task array

Users

Get users from a list

curl "api.yanado.com/public-api/lists/{listId}/users" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.UsersApi();
api.get_users_from_list(list_id);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.UsersApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
UsersApi api = new UsersApi(apiClient);
api.getUsersFromList(listId);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\UsersApi($api_client);
$api->getUsersFromList(list_id);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getUsersFromList(listId: mylistId, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::UsersApi.new

list_id = "list_id_example" # String | List id


begin
  #Get users from a list
  result = api_instance.get_users_from_list(list_id)
  p result
rescue ::ApiError => e
  puts "Exception when calling UsersApi->get_users_from_list: #{e}"
end

The above command returns JSON structured like this:

[ {
  "email" : "str",
  "id" : "str",
  "name" : "str"
} ]

HTTP Request

GET /public-api/lists/{listId}/users

Path Parameters

Parameter Required Type Description
listId true string List id

Responses for status codes

200 403 500
User array

Get users from a team

curl "api.yanado.com/public-api/users" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.UsersApi();
api.get_users(list_id);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.UsersApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
UsersApi api = new UsersApi(apiClient);
api.getUsers(listId);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\UsersApi($api_client);
$api->getUsers(list_id);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getUsers(listId: mylistId, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::UsersApi.new

opts = { 
  list_id: "list_id_example" # String | List id
}

begin
  #Get users from a team
  result = api_instance.get_users(opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling UsersApi->get_users: #{e}"
end

The above command returns JSON structured like this:

[ {
  "email" : "str",
  "id" : "str",
  "name" : "str"
} ]

HTTP Request

GET /public-api/users

Query Parameters

Parameter Required Type Description
listId false string List id

Responses for status codes

200 403 500
User array

Statuses

Get statuses from a list

curl "api.yanado.com/public-api/lists/{listId}/statuses" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.StatusesApi();
api.get_statuses(list_id);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.StatusesApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
StatusesApi api = new StatusesApi(apiClient);
api.getStatuses(listId);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\StatusesApi($api_client);
$api->getStatuses(list_id);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getStatuses(listId: mylistId, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::StatusesApi.new

list_id = "list_id_example" # String | List id


begin
  #Get statuses from a list
  result = api_instance.get_statuses(list_id)
  p result
rescue ::ApiError => e
  puts "Exception when calling StatusesApi->get_statuses: #{e}"
end

The above command returns JSON structured like this:

[ {
  "id" : "str",
  "name" : "str"
} ]

HTTP Request

GET /public-api/lists/{listId}/statuses

Path Parameters

Parameter Required Type Description
listId true string List id

Responses for status codes

200 403 500
Status array

Lists

Get lists

curl "api.yanado.com/public-api/lists" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.ListsApi();
api.get_lists();
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.ListsApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
ListsApi api = new ListsApi(apiClient);
api.getLists();


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\ListsApi($api_client);
$api->getLists();

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getLists(, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::ListsApi.new

begin
  #Get lists
  result = api_instance.get_lists
  p result
rescue ::ApiError => e
  puts "Exception when calling ListsApi->get_lists: #{e}"
end

The above command returns JSON structured like this:

[ {
  "id" : "str",
  "name" : "str"
} ]

HTTP Request

GET /public-api/lists

Responses for status codes

200 403 500
List array

Tasks

Get tasks

curl "api.yanado.com/public-api/tasks" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.TasksApi();
api.get_tasks(list_id, assignee, status_id, query);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.TasksApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
TasksApi api = new TasksApi(apiClient);
api.getTasks(listId, assignee, statusId, query);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\TasksApi($api_client);
$api->getTasks(list_id, assignee, status_id, query);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getTasks(listId: mylistId, assignee: myassignee, statusId: mystatusId, query: myquery, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::TasksApi.new

opts = { 
  list_id: "list_id_example", # String | List id
  assignee: "assignee_example", # String | Assignee
  status_id: "status_id_example", # String | Status Id
  query: "query_example" # String | Query
}

begin
  #Get tasks
  result = api_instance.get_tasks(opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling TasksApi->get_tasks: #{e}"
end

The above command returns JSON structured like this:

[ {
  "assigneeId" : "str",
  "assigneeName" : "str",
  "createTime" : "2016-03-03T10:15:30.00Z",
  "description" : "str",
  "dueDate" : "2016-03-03T10:15:30.00Z",
  "highPriority" : false,
  "listId" : "str",
  "listName" : "str",
  "name" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskId" : "str"
} ]

HTTP Request

GET /public-api/tasks

Query Parameters

Parameter Required Type Description
listId false string List id
assignee false string Assignee
statusId false string Status Id
query false string Query

Responses for status codes

200 403 500
Task array

Create task

curl "api.yanado.com/public-api/tasks" -H "X-API-Key: myX-API-Key" -X POST -d @- << EOF 
{
  "assigneeId" : "str",
  "description" : "str",
  "dueDate" : "2016-03-03T10:15:30.00Z",
  "form" : {
    "prop" : { }
  },
  "listId" : "str",
  "name" : "str",
  "statusId" : "str",
  "threadEmail" : "str",
  "threadId" : "str",
  "threadName" : "str",
  "threadSubject" : "str"
}
EOF

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.TasksApi();
api.create_task(task_request);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.TasksApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
TasksApi api = new TasksApi(apiClient);
api.createTask(taskRequest);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\TasksApi($api_client);
$api->createTask(task_request);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.createTask(taskRequest: mytaskRequest, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::TasksApi.new

opts = { 
  task_request: SwaggerClient::RequestTask.new # RequestTask | Body
}

begin
  #Create task
  result = api_instance.create_task(opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling TasksApi->create_task: #{e}"
end

The above command returns JSON structured like this:

{
  "assigneeId" : "str",
  "assigneeName" : "str",
  "createTime" : "2016-03-03T10:15:30.00Z",
  "description" : "str",
  "dueDate" : "2016-03-03T10:15:30.00Z",
  "highPriority" : false,
  "listId" : "str",
  "listName" : "str",
  "name" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskId" : "str"
}

HTTP Request

POST /public-api/tasks

Body Parameters

Parameter Required Type Description
assigneeId false string Assignee id
description false string Description
dueDate false string (date-time) Due date
form false object
listId true string List id
name true string Name
statusId true string Status Id
threadEmail false string Participant email
threadId false string Thread id
threadName false string Subject
threadSubject false string Subject

Responses for status codes

200
Task

Get task

curl "api.yanado.com/public-api/tasks/{taskId}" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.TasksApi();
api.get_task(task_id);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.TasksApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
TasksApi api = new TasksApi(apiClient);
api.getTask(taskId);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\TasksApi($api_client);
$api->getTask(task_id);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getTask(taskId: mytaskId, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::TasksApi.new

task_id = "task_id_example" # String | Task id


begin
  #Get task
  result = api_instance.get_task(task_id)
  p result
rescue ::ApiError => e
  puts "Exception when calling TasksApi->get_task: #{e}"
end

The above command returns JSON structured like this:

{
  "assigneeId" : "str",
  "assigneeName" : "str",
  "createTime" : "2016-03-03T10:15:30.00Z",
  "description" : "str",
  "dueDate" : "2016-03-03T10:15:30.00Z",
  "highPriority" : false,
  "listId" : "str",
  "listName" : "str",
  "name" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskId" : "str"
}

HTTP Request

GET /public-api/tasks/{taskId}

Path Parameters

Parameter Required Type Description
taskId true string Task id

Responses for status codes

200 403 500
Task

Update task

curl "api.yanado.com/public-api/tasks/{taskId}" -H "X-API-Key: myX-API-Key" -X PUT -d @- << EOF 
{ }
EOF

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.TasksApi();
api.update_task(task_id, task_request);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.TasksApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
TasksApi api = new TasksApi(apiClient);
api.updateTask(taskId, taskRequest);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\TasksApi($api_client);
$api->updateTask(task_id, task_request);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.updateTask(taskId: mytaskId, taskRequest: mytaskRequest, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::TasksApi.new

task_id = "task_id_example" # String | Task id

opts = { 
  task_request: SwaggerClient::UpdateRequestTask.new # UpdateRequestTask | Body
}

begin
  #Update task
  result = api_instance.update_task(task_id, opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling TasksApi->update_task: #{e}"
end

The above command returns JSON structured like this:

{
  "assigneeId" : "str",
  "assigneeName" : "str",
  "createTime" : "2016-03-03T10:15:30.00Z",
  "description" : "str",
  "dueDate" : "2016-03-03T10:15:30.00Z",
  "highPriority" : false,
  "listId" : "str",
  "listName" : "str",
  "name" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskId" : "str"
}

HTTP Request

PUT /public-api/tasks/{taskId}

Path Parameters

Parameter Required Type Description
taskId true string Task id

Body Parameters

Parameter Required Type Description
archived false boolean Archived
assigneeId false string Assignee id
description false string Description
dueDate false string (date-time) Due date
form false object
listId false string List id
name false string Name
statusId false string Status Id

Responses for status codes

200
Task

Comments

Get comments

curl "api.yanado.com/public-api/comments" -H "X-API-Key: myX-API-Key" -X GET

from ..api_client import ApiClient;
from ..configuration import Configuration

apiClient = client.ApiClient("api.yanado.com")
apiClient.configuration.api_key['X-API-Key'] = 'myApiKey'

api = client.CommentsApi();
api.get_comments(list_id, query);
import io.swagger.client.api.ApiClient;
import io.swagger.client.api.CommentsApi;

ApiClient apiClient = new ApiClient();
apiClient.getAuthentication("X-API-Key").setApiKey("myApiKey");
CommentsApi api = new CommentsApi(apiClient);
api.getComments(listId, query);


require_once('/path/to/Swagger\Client\Api');

$api_client = new Swagger\Client\ApiClient('api.yanado.com');

$api_client->getConfig().setApiKey("X-API-Key", "myApiKey");

$api = new Swagger\Client\CommentsApi($api_client);
$api->getComments(list_id, query);

var client = require('swagger-client');

var swagger = new client({
  url: 'https://app.rakam.com/api/swagger.json',
  authorizations : {

    "X-API-Key": new client.ApiKeyAuthorization("X-API-Key", "myApiKey", "header");

  },
  success: function() {
      swagger.pet.getComments(listId: mylistId, query: myquery, {responseContentType: 'application/json'}, function(response) {
          console.log(response);
      });
  }
});

# load the gem
require ''
# setup authorization
.configure do |config|
  # Configure API key authorization: X-API-Key
  config.api_key['X-API-Key'] = 'YOUR API KEY'
  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
  #config.api_key_prefix['X-API-Key'] = 'Bearer'
end

api_instance = ::CommentsApi.new

opts = { 
  list_id: "list_id_example", # String | List id
  query: "query_example" # String | Query
}

begin
  #Get comments
  result = api_instance.get_comments(opts)
  p result
rescue ::ApiError => e
  puts "Exception when calling CommentsApi->get_comments: #{e}"
end

The above command returns JSON structured like this:

[ {
  "assigneeId" : "str",
  "assigneeName" : "str",
  "created" : "2016-03-03T10:15:30.00Z",
  "id" : "str",
  "listId" : "str",
  "listName" : "str",
  "message" : "str",
  "statusId" : "str",
  "statusName" : "str",
  "taskCreated" : "2016-03-03T10:15:30.00Z",
  "taskDescription" : "str",
  "taskDueDate" : "2016-03-03T10:15:30.00Z",
  "taskHighPriority" : false,
  "taskId" : "str",
  "taskName" : "str",
  "userId" : "str",
  "userName" : "str"
} ]

HTTP Request

GET /public-api/comments

Query Parameters

Parameter Required Type Description
listId false string List id
query false string Query

Responses for status codes

200 403 500
Comment array

Definitions

Status

name description required schema default
id Id false string
name Name false string

Comment

name description required schema default
assigneeId Task assignee id false string
assigneeName Task assignee name false string
created Created false string (date-time)
id Id false string
listId Task list id false string
listName Task list name false string
message Message false string
statusId Task status id false string
statusName Task status name false string
taskCreated Task created false string (date-time)
taskDescription Task description false string
taskDueDate Task due date false string (date-time)
taskHighPriority Task high priority false boolean
taskId Task id false string
taskName Task Name false string
userId User id false string
userName User name false string

Task

name description required schema default
assigneeId Assignee id false string
assigneeName Assignee name false string
createTime Created false string (date-time)
description Description false string
dueDate Due date false string (date-time)
highPriority Hight priority false boolean
listId List id false string
listName List name false string
name Name false string
statusId Status Id false string
statusName Status name false string
taskId Id false string

User

name description required schema default
email Email false string
id Id false string
name Name false string

List

name description required schema default
id Id false string
name Name false string

Email Task

name description required schema default
assigneeId Task assignee id false string
assigneeName Task assignee name false string
id Id false integer (int32)
listId Task list id false string
listName Task list name false string
participantEmail Participant email false string
participantName Participant name false string
statusId Task status id false string
statusName Task status name false string
subject Subject false string
taskCreated Task created false string (date-time)
taskDescription Task description false string
taskDueDate Task due date false string (date-time)
taskHighPriority Task high priority false boolean
taskId Task id false string
taskName Task Name false string
threadId Thread id false string

Notification

name description required schema default
assigneeId Task assignee id false string
assigneeName Task assignee name false string
created Created false string (date-time)
id Id false integer (int64)
listId Task list id false string
listName Task list name false string
statusId Task status id false string
statusName Task status name false string
taskCreated Task created false string (date-time)
taskDescription Task description false string
taskDueDate Task due date false string (date-time)
taskHighPriority Task high priority false boolean
taskId Task id false string
taskName Task Name false string
userId User id false string
userName User name false string

Errors

The API uses the following error codes:

Error Code Meaning
400 Bad Request
401 Unauthorized -- Your API key is wrong
403 Forbidden
404 Not Found
405 Method Not Allowed
429 Too Many Requests
500 Internal Server Error
503 Service Unavailable ( Maintenance )
ruby java javascript php python