API Documentation

Authentication

To use the Desklog API, all requests must be authenticated to ensure secure and authorized access. Desklog uses Bearer Token authentication, which requires including your API token in the request header.

You can find your API integration setup and generate your API token by navigating to: Desklog → Settings → Integration → Desklog Api Integration

Make sure to keep your token secure, as it provides access to your Desklog data. Include this token in the header of every API request to successfully interact with the API.

Authentication Header Format:

Bash

                          
                          Authorization: Bearer {your_api_token}
                        

API's

The API folder contains all the endpoints available for interacting with the Desklog platform. Each endpoint is designed to perform specific operations, such as retrieving, updating, or managing data related to user details, teams, and reports.

Base URL:

All API requests should be sent to the following base URL:

https://app.desklog.io/api/v2/

This folder serves as the central hub for accessing Desklog's public API capabilities, ensuring seamless integration with your applications. Use these endpoints to view and edit user details, manage teams, and retrieve detailed reports like attendance logs.

Ping

The "ping" section in the Desklog API allows users to verify the connectivity and availability of the API server. By sending a request to this endpoint, users can quickly check if the server is responsive and operational, helping them troubleshoot any potential issues with their integration.

Responses

200

Response Attributes

status boolean

time number

Current UTC timestamp

message string

GET/api/v2/ping

  curl --location 'https://app.desklog.io/api/v2/ping' 
                  


    require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/ping")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)

response = https.request(request)
puts response.read_body


                  

import requests
import json

url = "https://app.desklog.io/api/v2/ping"

payload = {}
headers = {
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)


                  

<?php
$client = new Client();
$headers = [
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/ping', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();


                  

         
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/ping")
  .method("GET", body)
  .build();
Response response = client.newCall(request).execute();


                


var myHeaders = new Headers();
var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/ping", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


              

               
package main
import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/ping"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
    return
  }

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

            

               
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/ping");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());



          

Response

200

                       
{
    "status": true,
    "time": 12346789,
    "message": "Ping success"
}

User List

The user_list section allows users to retrieve a list of all users within the system. This functionality enables users to easily view and manage user data, such as user IDs, names, and contact information. By accessing this section, users can efficiently maintain and update their user database.

Header parameters

Authorization string

A header parameter containing the authorization token for accessing the user list API endpoint.

Body parameters

status string

user status - active or archived

Enum values: active archive

role array

admin, manager, team_leader or user

tracking_type string

Enum values: app web

Responses

200 400 500

Response Attributes

status boolean

message string

data array

id number

name string

email string

active boolean

Archive status of user.

phone string

team_id number

id of team which the user is part of.

team_name string

Name of team which the user is part of.

user_type string

user type of user - admin. manager, team_leader or user

role string

defined role for user

time_zone string

timezone of user

app_and_os string

App version and Os details of user.

POST/api/v2/user_list

curl --location --request GET 'https://app.desklog.io/api/v2/user_list' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
  "status": "active",
  "role": {},
  "tracking_type": "app"
}'


  
                    
                  

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/user_list")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "status": "active",
  "role": {},
  "tracking_type": "app"
})

response = https.request(request)
puts response.read_body


                      
                  

import requests
import json

url = "https://app.desklog.io/api/v2/user_list"

payload = json.dumps({
  "status": "active",
  "role": {},
  "tracking_type": "app"
})
headers = {
  'Authorization': '{{AUTH_TOKEN}}',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)


                      
                  


$client = new Client();
$headers = [
  'Authorization' => '{{AUTH_TOKEN}}',
  'Content-Type' => 'application/json'
];
$body = '{
  "status": "active",
  "role": {},
  "tracking_type": "app"
}';
$request = new Request('GET', 'https://app.desklog.io/api/v2/user_list', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();


                      
                  

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
  \"status\": \"active\",
  \"role\": {},
  \"tracking_type\": \"app\"
}");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/user_list")
  .method("GET", body)
  .addHeader("Authorization", "{{AUTH_TOKEN}}")
  .build();
Response response = client.newCall(request).execute();
  
                      
                  

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
  "status": "active",
  "role": {},
  "tracking_type": "app"
});

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/user_list", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
                  

package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/user_list"
  method := "GET"

  payload := strings.NewReader(`{
  "status": "active",
  "role": {},
  "tracking_type": "app"
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
                  

                Response
                
            

                
                  
                  200
                
                
                  
                  400
                
                
                  
                  500
                
              
  {
  "status": true,
  "message": "success",
  "data": [
    {
      "id": 1,
      "name": "John Doe",
      "email": "john@doe.com",
      "active": true,
      "phone": "123456789",
      "team_id": 1,
      "team_name": "Team 1",
      "user_type": "admin",
      "role": "System Admin",
      "time_zone": "UTC",
      "app_and_os": "desklog_2.21_Windows_11"
    }
  ]
  }
                    

  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
                    

  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
      

User Profile

The user profile section allows users to retrieve detailed information about a specific user within the Desklog system. By accessing this section, users can view profile information such as user details, preferences, and settings. This section provides a centralized location for user-specific data, simplifying the process of retrieving and updating user information.

Header parameters

Authorization string

This header parameter is used to authenticate the user and authorize access to the user_profile endpoint.

Body parameters

email string Required

This body parameter is used to provide the email address of the user for fetching their profile information.

Responses

200 400 500

Response Attributes

status boolean

message string

data object

id string

name string

email string

active boolean

Archive status of user.

phone string

team_id number

id of team which the user is part of.

team_name string

Name of team which the user is part of.

user_type string

user type of user - admin. manager, team_leader or user

role string

defined role for user

time_zone string

timezone of user

app_and_os string

App version and Os details of user.

POST/api/v2/user_profile

curl --location --request GET 'https://app.desklog.io/api/v2/user_profile' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data-raw '{
"email": "john@doe.com"
}'
                

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/user_profile")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"email": "john@doe.com"
})

response = https.request(request)
puts response.read_body

                

import requests
import json

url = "https://app.desklog.io/api/v2/user_profile"

payload = json.dumps({
"email": "john@doe.com"
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

                

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"email": "john@doe.com"
}';
$request = new Request('GET', 'https://app.desklog.io/api/v2/user_profile', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"email\": \"john@doe.com\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/user_profile")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
                

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"email": "john@doe.com"
});

var requestOptions = {
method: 'GET',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/user_profile", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
                

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/user_profile"
method := "GET"

payload := strings.NewReader(`{
"email": "john@doe.com"
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
  fmt.Println(err)
  return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
  fmt.Println(err)
  return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
  fmt.Println(err)
  return
}
fmt.Println(string(body))
}
                

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/user_profile");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"email\": \"john@doe.com\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

                

              Response
              
          

              
                
                200
              
              
                
                400
              
              
                
                500
              
            
{
"status": true,
"message": "success",
"data": {
  "id": "1",
  "name": "John Doe",
  "email": "john@doe.com",
  "active": true,
  "phone": "123456789",
  "team_id": 1,
  "team_name": "Team 1",
  "user_type": "admin",
  "role": "System Admin",
  "time_zone": "UTC",
  "app_and_os": "desklog_2.21_Windows_11"
}
}
                  

{
  "status": false,
  "message": "Error message",
  "data": {}
}
                  

{
  "status": false,
  "message": "Error message",
  "data": {}
}
    

User Profile Update

The user profile update section allows users to update their profile information in Desklog seamlessly. Users can modify their email, name, and phone number to ensure accurate and up-to-date personal details within the platform. This functionality enables users to keep their profiles current and relevant for effective communication and record-keeping.

Header parameters

Authorization string

The authorization token for accessing the API.

Body parameters

email string Required

The email address associated with the user's profile.

new_name string

The new name to be updated for the user's profile.

new_phone number

The new phone number to be updated for the user's profile.

Responses

200 400 500

Response Attributes

status boolean

message string

data object

POST/api/v2/user_profile_update

curl --location 'https://app.desklog.io/api/v2/user_profile_update' \
  --header 'Authorization: {{AUTH_TOKEN}}' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "email": "john@doe.com",
    "new_name": "john doe",
    "new_phone": 123123123
  }'

                  

require "uri"
  require "json"
  require "net/http"
  
  url = URI("https://app.desklog.io/api/v2/user_profile_update")
  
  https = Net::HTTP.new(url.host, url.port)
  https.use_ssl = true
  
  request = Net::HTTP::Post.new(url)
  request["Authorization"] = "{{AUTH_TOKEN}}"
  request["Content-Type"] = "application/json"
  request.body = JSON.dump({
    "email": "john@doe.com",
    "new_name": "john doe",
    "new_phone": 123123123
  })
  
  response = https.request(request)
  puts response.read_body
  

                  

import requests
  import json
  
  url = "https://app.desklog.io/api/v2/user_profile_update"
  
  payload = json.dumps({
    "email": "john@doe.com",
    "new_name": "john doe",
    "new_phone": 123123123
  })
  headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
  }
  
  response = requests.request("POST", url, headers=headers, data=payload)
  
  print(response.text)
  

                  


  $client = new Client();
  $headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
  ];
  $body = '{
    "email": "john@doe.com",
    "new_name": "john doe",
    "new_phone": 123123123
  }';
  $request = new Request('POST', 'https://app.desklog.io/api/v2/user_profile_update', $headers, $body);
  $res = $client->sendAsync($request)->wait();
  echo $res->getBody()->getContents();

                  

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
  \"email\": \"john@doe.com\",
  \"new_name\": \"john doe\",
  \"new_phone\": 123123123
}");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/user_profile_update")
  .method("POST", body)
  .addHeader("Authorization", "{{AUTH_TOKEN}}")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

                  

var myHeaders = new Headers();
  myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
  myHeaders.append("Content-Type", "application/json");
  
  var raw = JSON.stringify({
    "email": "john@doe.com",
    "new_name": "john doe",
    "new_phone": 123123123
  });
  
  var requestOptions = {
    method: 'POST',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
  };
  
  fetch("https://app.desklog.io/api/v2/user_profile_update", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));

                  

package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/user_profile_update"
  method := "POST"

  payload := strings.NewReader(`{
  "email": "john@doe.com",
  "new_name": "john doe",
  "new_phone": 123123123
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

                  

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/user_profile_update");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"email\": \"john@doe.com\",
\"new_name\": \"john doe\",
\"new_phone\": 123123123
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync()); 

                  

                Response
                
                  200
                
                  400
                
                  500
                
  {
    "status": true,
    "message": "User profile successfully updated",
    "data": {}
  }
                    
  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
                    
  {
    "status": false,
    "message": "Error message",
    "data": {}
  }

User Register

The "user register" section allows users to create a new user within the Desklog platform. By providing the necessary information, users can easily register and gain access to all features and functionalities offered by Desklog. This API section simplifies the user registration process, enabling seamless onboarding for new users.

Header parameters

Authorization string

This header parameter is used to authenticate the user during the user registration process. It is required for access to the POST /api/v2/user_register endpoint.

Body parameters

user_role number Required

Role id of user - Can be obtained from /user_roles api

email string Required

tracking_selected string Required

preferred tracking type of user

Enum values: app Web

team number

id of team which the user should be placed under.

tracking_type string

employee_id number

punching_id number

jira_account_id string

clickup_id number

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/user_register

                                            curl --location 'https://app.desklog.io/api/v2/user_register' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data-raw '{
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": null,
  "punching_id": null,
  "jira_account_id": null,
  "clickup_id": null
}'
                    
                  

                                            require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/user_register")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": nil,
  "punching_id": nil,
  "jira_account_id": nil,
  "clickup_id": nil
})

response = https.request(request)
puts response.read_body
      
                  

                                            import requests
import json

url = "https://app.desklog.io/api/v2/user_register"

payload = json.dumps({
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": None,
  "punching_id": None,
  "jira_account_id": None,
  "clickup_id": None
})
headers = {
  'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                      
                  

                                            <?php
$client = new Client();
$headers = [
  'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": null,
  "punching_id": null,
  "jira_account_id": null,
  "clickup_id": null
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/user_register', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                      
                  

                                            OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
  \"user_role\": 1,
  \"email\": \"john@doe.com\",
  \"tracking_selected\": \"app\",
  \"team\": 1,
  \"employee_id\": null,
  \"punching_id\": null,
  \"jira_account_id\": null,
  \"clickup_id\": null
}");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/user_register")
  .method("POST", body)
  .addHeader("Authorization", "{{AUTH_TOKEN}}")
  .build();
Response response = client.newCall(request).execute();
  
                      
                  

                                            var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": null,
  "punching_id": null,
  "jira_account_id": null,
  "clickup_id": null
});

var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/user_register", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
  
                  

            package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/user_register"
  method := "POST"

  payload := strings.NewReader(`{
  "user_role": 1,
  "email": "john@doe.com",
  "tracking_selected": "app",
  "team": 1,
  "employee_id": null,
  "punching_id": null,
  "jira_account_id": null,
  "clickup_id": null
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
                  

                Response
                
                  200
                
                  400
                
                  500
                
  {
    "status": true,
    "message": "User added successfully",
    "data": null
  }
                    
  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
                    
  {
    "status": false,
    "message": "Error message",
    "data": {}
  }

Team List

The team list section allows users to retrieve a list of teams within their organization, providing valuable insights into the structure and composition of their workforce. With this information, users can effectively manage team assignments and streamline communication and collaboration within their organization.

Header parameters

Authorization string

Specifies the authentication token needed to access the API endpoint. This parameter is required for every request to the team_list endpoint.

Responses

200 400 500

Response Attributes

status boolean

message string

data array

team_id number

id of team

team_name string

name of team

lead_by number

user id of user who leads the team

added_by boolean

user id of user who created the team

POST/api/v2/user_register

 
curl --location 'https://app.desklog.io/api/v2/team_list' \
--header 'Authorization: {{AUTH_TOKEN}}' \
                    
                  

                                            require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/team_list")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
    
                  

                                            import requests
import json

url = "https://app.desklog.io/api/v2/team_list"

payload = {}
headers = {
  'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

                      
                  

                                            <?php
$client = new Client();
$headers = [
  'Authorization' => '{{AUTH_TOKEN}}',
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/team_list', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                      
                  

                                            OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/team_list")
  .method("GET", body)
  .addHeader("Authorization", "{{AUTH_TOKEN}}")
  .build();
Response response = client.newCall(request).execute();
  
                      
                  

                                            var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/team_list", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
  
                  

            package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/team_list"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
                  

                Response
                
            

                
                  
                  200
                
                
                  
                  400
                
                
                  
                  500
                
              
  {
    "status": true,
    "message": "Success",
    "data": [
      {
        "team_id": 1,
        "team_name": "RD-1",
        "lead_by": 9,
        "added_by": 1
      }
    ]
  }
                    

  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
                    

  {
    "status": false,
    "message": "Error message",
    "data": {}
  }
      

Team Details

The team details section allows users to retrieve detailed information about a specific team. By using this API, users can access essential data related to a team, such as member details. This functionality enables seamless collaboration and efficient management within the team.

Header parameters

Authorization string

A header parameter used to authenticate the request and verify the identity of the user making the API call.

Body parameters

team_id number Required

Responses

200 400 500

Response Attributes

status boolean

message string

data object

id number

id of team

team_name string

name of team

lead_by number

user id of user who leads the team

added_by number

user id of user who created the team

members array

user_id number

user id of user

email string

email of user

POST/api/v2/team_show

                                            curl --location 'https://app.desklog.io/api/v2/team_show' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_id": 1
}'
                  
                

                                            require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/team_show")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_id": 1
})

response = https.request(request)
puts response.read_body

                

                                            import requests
import json

url = "https://app.desklog.io/api/v2/team_show"

payload = json.dumps({
"team_id": 1
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                    
                

                                            <?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_id": 1
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/team_show', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                    
                

                                            OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_id\": 1
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/team_show")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

                    
                

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_id": 1
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/team_show", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

                

package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/team_show"
method := "POST"

payload := strings.NewReader(`{
"team_id": 1
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
  fmt.Println(err)
  return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
  fmt.Println(err)
  return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
  fmt.Println(err)
  return
}
fmt.Println(string(body))
}
                

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/team_show");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"team_id\": 1
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


                

              Response
              
          

              
                
                200
              
              
                
                400
              
              
                
                500
              
            
{
  "status": true,
  "message": "Success",
  "data": {
    "id": 1,
    "team_name": "Team 1",
    "lead_by": 1,
    "added_by": 1,
    "members": [
      {
        "user_id": 91,
        "email": "john@doe.com"
      }
    ]
  }
}
                  

{
  "status": false,
  "message": "Error message",
  "data": {}
}
                  

{
  "status": false,
  "message": "Error message",
  "data": {}
}
    

Team Create

The team create section allows users to create a new team within the Desklog platform. By providing essential information such as team name, lead, and team members, users can establish a cohesive group for collaboration and project management. This API endpoint streamlines the process of setting up teams, facilitating efficient communication and workflow organization within the system.

Header parameters

Authorization string

The API key used to authenticate the request.

Body parameters

team_name string Required

The name of the team that is being created.

team_member array Required

The user ID of a team member to be added to the team.

lead_by number

The user ID of the team leader who will be creating the team.

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/team_create

curl --location 'https://app.desklog.io/api/v2/team_create' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
}'
                  
                

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/team_create")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
})

response = https.request(request)
puts response.read_body

                

import requests
import json

url = "https://app.desklog.io/api/v2/team_create"

payload = json.dumps({
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                    
                

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/team_create', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                    
                

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_name\": \"Team 1\",
\"team_member\": [
  1,
  2
],
\"lead_by\": 1
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/team_create")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

                    
                

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/team_create", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

                

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/team_create"
method := "POST"

payload := strings.NewReader(`{
"team_name": "Team 1",
"team_member": [
  1,
  2
],
"lead_by": 1
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
  fmt.Println(err)
  return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
  fmt.Println(err)
  return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
  fmt.Println(err)
  return
}
fmt.Println(string(body))
}
                

              Response
              
                200
              
                400
              
                500
              
{
  "status": true,
  "message": "New team created successfully.",
  "data": null
}
                  
{
  "status": false,
  "message": "Error message",
  "data": {}
}
                  
{
  "status": false,
  "message": "Error message",
  "data": {}
}

Team Delete

The team delete section allows users to remove a team from Desklog, effectively deleting all associated data and members. By utilizing this API endpoint, users can effectively manage their teams and maintain accurate records within the Desklog platform.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the request and must contain a valid token for the API to process the team deletion.

Body parameters

team_id number Required

The team_id body parameter specifies the unique identifier of the team that is to be deleted from the system.

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/team_show

curl --location 'https://app.desklog.io/api/v2/team_delete' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_id": 1
}'
                
              

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/team_delete")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_id": 1
})

response = https.request(request)
puts response.read_body

              

import requests
import json

url = "https://app.desklog.io/api/v2/team_delete"

payload = json.dumps({
"team_id": 1
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                  
              

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_id": 1
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/team_delete', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                  
              

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_id\": 1
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/team_delete")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

                  
              

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_id": 1
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/team_delete", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

              

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/team_delete"
method := "POST"

payload := strings.NewReader(`{
"team_id": 1
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
              

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/team_delete");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"team_id\": 1
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


              

            Response
            
              200
            
              400
            
              500
            
{
"status": true,
"message": "Team has been deleted successfully!",
"data": null
}
                
{
"status": false,
"message": "Error message",
"data": {}
}
                
{
"status": false,
"message": "Error message",
"data": {}
}

Rename Team

The "rename_team" section allows users to update the name of a specific team within the Desklog platform. By using this API feature, users can easily customize the team name to better reflect their organization's structure or branding. This functionality enhances the overall user experience and ensures that team information remains up-to-date and relevant.

Header parameters

Authorization string

The Authorization header parameter contains the authentication token required to access the rename_team endpoint.

Body parameters

team_id number Required

The team_id body parameter specifies the unique identifier of the team that is to be renamed.

team_name string Required

The team_name body parameter represents the new name that will be assigned to the team identified by team_id.

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/rename_team

curl --location 'https://app.desklog.io/api/v2/rename_team' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_id": 1,
"team_name": "Team Name"
}'
                
              

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/rename_team")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_id": 1,
"team_name": "Team Name"
})

response = https.request(request)
puts response.read_body

              

import requests
import json

url = "https://app.desklog.io/api/v2/rename_team"

payload = json.dumps({
"team_id": 1,
"team_name": "Team Name"
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                  
              

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_id": 1,
"team_name": "Team Name"
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/rename_team', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                  
              

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_id\": 1,
\"team_name\": \"Team Name\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/rename_team")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

                  
              

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_id": 1,
"team_name": "Team Name"
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/rename_team", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

              

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/rename_team"
method := "POST"

payload := strings.NewReader(`{
"team_id": 1,
"team_name": "Team Name"
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
              

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/rename_team");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"team_id\": 1,
\"team_name\": \"Team Name\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


              

            Response
            
              200
            
              400
            
              500
            
{
"status": true,
"message": "Team Name Changed",
"data": null
}
                
{
"status": false,
"message": "Error message",
"data": {}
}
                
{
"status": false,
"message": "Error message",
"data": {}
}

Add Team Member

The "add team member" section allows users to seamlessly add new members to their team within the Desklog system. By utilizing this functionality, users can easily expand their team and streamline collaboration with new members. This API section simplifies the process of onboarding new team members, enhancing efficiency and productivity within the organization.

Header parameters

Authorization string

A header parameter that contains the authentication token for the request.

Body parameters

team_id number Required

A body parameter that specifies the ID of the team to which the new member will be added.

new_member array Required

A body parameter that provides the details of the new member being added to the team.

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/add_team_member

curl --location 'https://app.desklog.io/api/v2/add_team_member' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_id": 1,
"new_member": [
2
]
}'
              

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/add_team_member")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_id": 1,
"new_member": [
2
]
})

response = https.request(request)
puts response.read_body

                  
              

import requests
import json

url = "https://app.desklog.io/api/v2/add_team_member"

payload = json.dumps({
"team_id": 1,
"new_member": [
2
]
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                  
              

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_id": 1,
"new_member": [
2
]
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/add_team_member', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();


                  
              

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_id\": 1,
\"new_member\": [
2
]
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/add_team_member")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

              

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_id": 1,
"new_member": [
2
]
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/add_team_member", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
              

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/add_team_member"
method := "POST"

payload := strings.NewReader(`{
"team_id": 1,
"new_member": [
2
]
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
              

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/add_team_member");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"team_id\": 1,
\"new_member\": [
2
]
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


              

            Response
            
              200
            
              400
            
              500
            
{
"status": true,
"message": "Team Name Changed",
"data": null
}
                
{
"status": false,
"message": "Error message",
"data": {}
}
                
{
"status": false,
"message": "Error message",
"data": {}
}

Remove Team Member

The "remove team member" section allows users to efficiently manage their team by removing a specific member from a designated team. By utilizing this functionality, users can streamline team organization and access control within their project or organization. This section facilitates the smooth handling of team member changes and permissions.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the request and verify the identity of the user making the API call

Body parameters

team_id number Required

The team_id body parameter specifies the unique identifier of the team from which the member will be removed.

member_id number Required

The member_id body parameter specifies the unique identifier of the team member to be removed from the specified team.

Responses

200 400 500

Response Attributes

status boolean

message string

data string

POST/api/v2/remove_team_member

curl --location 'https://app.desklog.io/api/v2/remove_team_member' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"team_id": 1,
"member_id": 2
}'
              

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/remove_team_member")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"team_id": 1,
"member_id": 2
})

response = https.request(request)
puts response.read_body

                  
              

import requests
import json

url = "https://app.desklog.io/api/v2/remove_team_member"

payload = json.dumps({
"team_id": 1,
"member_id": 2
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

                  
              

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"team_id": 1,
"member_id": 2
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/remove_team_member', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();


                  
              

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"team_id\": 1,
\"member_id\": 2
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/remove_team_member")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();

              

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"team_id": 1,
"member_id": 2
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/remove_team_member", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
              

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/remove_team_member"
method := "POST"

payload := strings.NewReader(`{
"team_id": 1,
"member_id": 2
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
              

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/remove_team_member");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"team_id\": 1,
\"member_id\": 2
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


              

            Response
            
              200
            
              400
            
              500
            
{
"status": true,
"message": "Team Name Changed",
"data": null
}
                
{
"status": false,
"message": "Error message",
"data": {}
}
                
{
"status": false,
"message": "Error message",
"data": {}
}

Attendance Report

The "attendance report" section in the Desklog API allows users to generate detailed reports of employee attendance within a specified date range. With this feature, users can track and analyze attendance data to gain insights into workforce patterns and trends. This section provides valuable information for monitoring employee attendance and improving overall productivity.

Header parameters

Authorization string

A security token to authorize access to the attendance report API endpoint.

Body parameters

from_date string Required

Specifies the start date for the attendance report to be generated.

to_date string Required

Specifies the end date for the attendance report to be generated.

user_id integer

user id of user. If given, report will be showed for the particular user.

Responses

200

Response Attributes

status boolean

message string

data array

team_id number

user id of user.

employee_id string

employee id of user.

name string

name of user.

email string

email of user.

team_name string

name of team which user is part of.

clock_in string

Clock in time of user. (If given a date range, average will be provided).

clock_out string

Clock out time of user. (If given a date range, average will be provided).

time_at_work string

Total worked time of user.

productive_time string

Total productive time of user.

focus_time string

Total focus time of user.

idle_time string

Total idle time of user.

private_time string

Total private time of user.

neutral_time string

Total neutral time of user.

non_productive_time string

Total non productive time of user.

over_time string

Total over time of user.

minimum_working_hours string

Minimum working hours of user.

activity_percentage number

Activity percentage of user.

efficiency_percentage string

Efficiency percentage of user.

task_assigned_time string

Total task assigned time of user.

task_spent_time string

Total task spent time of user.

isWorkWithIdle number

Whether time at work includes idle time or not

time_zone string

Time zone of user

client_app_details string

App version and Os details details of user

POST/api/v2/attendance_report

curl --location --request GET 'https://app.desklog.io/api/v2/attendance_report' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--data '{
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
}'
              

require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/attendance_report")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request.body = JSON.dump({
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
})

response = https.request(request)
puts response.read_body

                  
              

import requests
import json

url = "https://app.desklog.io/api/v2/attendance_report"

payload = json.dumps({
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
})
headers = {
'Authorization': '{{AUTH_TOKEN}}',
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

                  
              

<?php
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
];
$body = '{
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
}';
$request = new Request('GET', 'https://app.desklog.io/api/v2/attendance_report', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

                  
              

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"from_date\": \"20-11-2024\",
\"to_date\": \"20-11-2024\",
\"user_id\": 1
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/attendance_report")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
              

var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var raw = JSON.stringify({
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
});

var requestOptions = {
method: 'GET',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/attendance_report", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
              

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/attendance_report"
method := "GET"

payload := strings.NewReader(`{
"from_date": "20-11-2024",
"to_date": "20-11-2024",
"user_id": 1
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
              

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/attendance_report");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
\"from_date\": \"20-11-2024\",
\"to_date\": \"20-11-2024\",
\"user_id\": 1
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());


              

            Response
            
        

            
              
              200
            
           
          
{
"status": true,
"message": "Success",
"data": [
{
  "user_id": 1,
  "employee_id": "1",
  "name": "John Doe",
  "email": "john@doe.com",
  "team_name": "Team 1",
  "clock_in": "11:31 AM",
  "clock_out": "01:56 PM",
  "time_at_work": "02h 30m",
  "productive_time": "02h 15m",
  "focus_time": "02h 30m",
  "idle_time": "--",
  "private_time": "--",
  "neutral_time": "00h 15m",
  "non_productive_time": "--",
  "over_time": "--",
  "minimum_working_hours": "08h 00m",
  "activity_percentage": 80,
  "efficiency_percentage": "--",
  "task_assigned_time": "08h 00m",
  "task_spent_time": "10h 28m",
  "isWorkWithIdle": 1,
  "time_zone": "Asia/Kolkata",
  "client_app_details": "desklog_2.21_Windows_11"
}
]
}
                

Project List

The "project_list" section in the desklog API allows users to retrieve a list of projects and their associated tasks within the system. By accessing this section, users can efficiently view and manage project details, track progress, and organize tasks effectively within their workspace. This section provides a clear overview of all ongoing projects and their respective tasks, streamlining project management processes for users.

Header parameters

Authorization string

The Authorization header parameter contains the authentication credentials required to access the project_list endpoint. It is used to verify the identity of the client making the request.

Query parameters

limit string

The limit parameter specifies the maximum number of projects to return in the response. If not provided, the default limit is applied.

offset string

The offset parameter is used to specify the starting point from which projects should be retrieved in the response. It determines the index of the first project to be returned.

Responses

200 400 500

Response Attributes

status boolean

message string

data array

id number

project_name string

access number

1 = Private (restricted access), 0 = Public (open access)

integrated_from string

project_status string

project_priority string

GET/api/v2/project/?limit=&offset=

        
curl --location 'https://app.desklog.io/api/v2/project/' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json'


              

  
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/project/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"

response = https.request(request)
puts response.read_body


                  
              

            
import requests
import json

url = "https://app.desklog.io/api/v2/project/"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)



              

               
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/project/', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
 
                                
              

               
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/project/")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();

 
              

          
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var requestOptions = {
    method: 'GET',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/project/", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));

     
              

   
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/project/"
    method := "GET"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}

 
              

             
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/project/");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

                
              

Response

200 400 500

                    
{
"status": true,
"message": "success",
"data": [
    {
    "id": 98,
    "project_name": "erf4t",
    "access": 1,
    "integrated_from": "desklog",
    "project_status": "Ongoing",
    "project_priority": "Intermediate"
    },
    {
    "id": 97,
    "project_name": "set2",
    "access": 1,
    "integrated_from": "desklog",
    "project_status": "Ongoing",
    "project_priority": "Low"
    }
]
}

                    
                

                                        
{
    "status": false,
    "message": "Error message",
    "data": {}
}
                    
                    
                  

                                        
{
    "status": false,
    "message": "Error message",
    "data": {}
}
                    
                    
                  

Project Details

The "project_details" section allows users to retrieve detailed information about a specific project, including its tasks, deadlines, and progress status. With this section, users can easily access and review project details to stay organized and informed about their work.

Header parameters

Authorization string

A header parameter that allows the client to authenticate and access the specified project information. It should contain the necessary credentials required for authorization.

Responses

200

Response Attributes

status boolean

message string

data object

id number

project_name string

access number

1 = Private (restricted access), 0 = Public (open access)

integrated_from string

project_status string

project_priority string

board_members array

1 number

5 number

project_working_hour number

estimated_amount string

GET/api/v2/project/117

            
curl --location 'https://app.desklog.io/api/v2/project/117' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json'
  
  
                

      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/project/117")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"

response = https.request(request)
puts response.read_body    
  
  
                    
                

                
import requests
import json

url = "https://app.desklog.io/api/v2/project/117"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
    
  
  
  
                

                   
    $client = new Client();
    $headers = [
      'Authorization' => '{{AUTH_TOKEN}}',
      'Content-Type' => 'application/json'
    ];
    $request = new Request('GET', 'https://app.desklog.io/api/v2/project/117', $headers);
    $res = $client->sendAsync($request)->wait();
    echo $res->getBody()->getContents();
    
   
                                  
                

                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/project/117")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
   
                

              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var requestOptions = {
    method: 'GET',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/project/117", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
       
                

       
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/project/117"
    method := "GET"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/project/117");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());    
  
                  
                

Response

200 400 500

                      
{
    "status": true,
    "message": "success",
    "data": {
        "id": 115,
        "project_name": "test public1",
        "access": null,
        "integrated_from": "desklog",
        "project_status": "Ongoing",
        "project_priority": "Intermediate",
        "board_members": [
        1,
        5
        ],
        "project_working_hour": 42,
        "estimated_amount": "650.00"
    }
    }
  
                      
                  

                                            
{
    "status": false,
    "message": "Project does not exist!.",
    "data": {}
    }
                      
                      
                    

                                            
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                      
                      
                    

Project Create

The project_create section allows users to create new project entries within the desklog system. By utilizing this functionality, users can efficiently establish and track project details such as project name, access levels, priority, client association, end date, estimated hours, and estimated amount. This API section streamlines the process of project creation and management, enhancing overall project organization and tracking capabilities.

Header parameters

Authorization string

The authorization token required for accessing the API and making requests. Ensures secure communication and authenticates the user.

Body Parameters

project_name string

The name of the project, providing a brief and clear identifier for the project. Should be unique and descriptive.

access number

The level of access granted for the project, specifying who can view, edit, or manage the project details. Can have values like read-only, write, or admin access. 1 = Private (restricted access), 0 = Public (open access)

priority number

The priority of the project, indicating its importance relative to other projects. Values can range from low to high. 1 > critical, 2 > intermediate, 3 > low,4 > trivial

client_id number

The unique identifier of the client associated with the project. Helps in linking the project with the client's information and interactions.

end_date string

The end date of the project, specifying when the project is expected to be completed. Should be in a valid date format.

project_estimated_hours number

The estimated number of hours required to complete the project. This helps in planning resource allocation and project timelines.

project_estimated_amount number

The estimated cost or budget allocated for the project. This helps in financial planning and tracking project expenses.

Responses

200

Response Attributes

status boolean

message string

data string

GET/api/v2/project

            
curl --location 'https://app.desklog.io/api/v2/project' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "project_name": "sample project",
    "access": null,
    "priority": 2,
    "client_id": 22,
    "end_date": "2025-03-31",
    "project_estimated_hours": 42,
    "project_estimated_amount": 650
}'
  
  
                

      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/project")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "project_name": "sample project",
    "access": nil,
    "priority": 2,
    "client_id": 22,
    "end_date": "2025-03-31",
    "project_estimated_hours": 42,
    "project_estimated_amount": 650
})

response = https.request(request)
puts response.read_body
      
  
  
                    
                

                
import requests
import json

url = "https://app.desklog.io/api/v2/project"

payload = json.dumps({
    "project_name": "sample project",
    "access": None,
    "priority": 2,
    "client_id": 22,
    "end_date": "2025-03-31",
    "project_estimated_hours": 42,
    "project_estimated_amount": 650
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
    
    
  
  
  
                

                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "project_name": "sample project",
    "access": null,
    "priority": 2,
    "client_id": 22,
    "end_date": "2025-03-31",
    "project_estimated_hours": 42,
    "project_estimated_amount": 650
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/project', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
   
                                  
                

                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"project_name\": \"sample project\",
\"access\": null,
\"priority\": 2,
\"client_id\": 22,
\"end_date\": \"2025-03-31\",
\"project_estimated_hours\": 42,
\"project_estimated_amount\": 650
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/project")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
   
                

              
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"project_name\": \"sample project\",
\"access\": null,
\"priority\": 2,
\"client_id\": 22,
\"end_date\": \"2025-03-31\",
\"project_estimated_hours\": 42,
\"project_estimated_amount\": 650
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/project")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
       
                

       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/project"
    method := "POST"

    payload := strings.NewReader(`{
    "project_name": "sample project",
    "access": null,
    "priority": 2,
    "client_id": 22,
    "end_date": "2025-03-31",
    "project_estimated_hours": 42,
    "project_estimated_amount": 650
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/project");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"project_name\": \"sample project\",
    \"access\": null,
    \"priority\": 2,
    \"client_id\": 22,
    \"end_date\": \"2025-03-31\",
    \"project_estimated_hours\": 42,
    \"project_estimated_amount\": 650
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
     
  
                  
                

Response

200 400 500

                      
{
    "status": true,
    "message": "Project created successfully",
    "data": {
        "project_id": 125
    }
}
  
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                      
{
    "status": false,
    "message": "Error message",
    "data": {}
    }

Project Delete

The project_delete section allows users to remove a specific project from the system. By utilizing this API, users can effectively manage their project lists and streamline their workflow by deleting unnecessary or completed projects. This section empowers users to maintain a clean and organized project environment within the desklog platform.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the client's request to delete the project with ID 117. It typically contains the API key or token required to authorize the operation.

Responses

200

Response Attributes

status boolean

message string

data string

GET/api/v2/project

            
curl --location --request DELETE 'https://app.desklog.io/api/v2/project/117' \
--header 'Authorization: {{AUTH_TOKEN}}'
  
require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/project/117")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
    
import requests

url = "https://app.desklog.io/api/v2/project/117"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
    
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('DELETE', 'https://app.desklog.io/api/v2/project/117', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/project/117")
.method("DELETE", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
  
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'DELETE',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/project/117", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/project/117"
    method := "DELETE"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://app.desklog.io/api/v2/project/117");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                      
{
    "status": true,
    "message": "Project deleted successfully",
    "data": null
    }
  
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                      
{
    "status": false,
    "message": "Error message",
    "data": {}
    }

Project Priority

Header Parameters

Authorization string

Query Parameters

limit string

offset string

GET/api/v2/priority?limit=10&offset=0

            
curl --location 'https://app.desklog.io/api/v2/priority?limit=10&offset=0' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json'
  
  
                

    
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/priority?limit=10&offset=0")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"

response = https.request(request)
puts response.read_body    
  
  
                    
                

    
import requests
import json

url = "https://app.desklog.io/api/v2/priority?limit=10&offset=0"

payload = {}
headers = {
  'Authorization': '{{AUTH_TOKEN}}',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
  
  
  
                

    
$client = new Client();
$headers = [
  'Authorization' => '{{AUTH_TOKEN}}',
  'Content-Type' => 'application/json'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/priority?limit=10&offset=0', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
   
                                  
                

    
  OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
  .url("https://app.desklog.io/api/v2/priority?limit=10&offset=0")
  .method("GET", body)
  .addHeader("Authorization", "{{AUTH_TOKEN}}")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();
  
   
                

    
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/priority?limit=10&offset=0", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));
  
       
                

    
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://app.desklog.io/api/v2/priority?limit=10&offset=0"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/priority?limit=10&offset=0");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
     
  
                  
                

Task List

The task_list section allows users to retrieve a list of tasks associated with a project in the desklog platform. Users can view and manage project tasks efficiently through this API section, facilitating improved project management and task tracking.

Header parameters

Authorization string

The Authorization header parameter is used for authentication and authorization purposes. It typically contains a bearer token or API key to validate the user's identity and permissions.

Query Parameters

limit string

The limit parameter is used to specify the maximum number of tasks to be returned in the response. It helps in pagination and controlling the number of results displayed.

offset string

The offset parameter is used to specify the starting point from which tasks should be retrieved. It helps in fetching results beyond the first set of tasks and is useful for pagination.

Responses

200

Response Attributes

status boolean

message string

data array

id number

task_title string

basic_status_id number

current_status string

GET/api/v2/task?limit=3&offset=1

            
curl --location 'https://app.desklog.io/api/v2/task?limit=3&offset=1' \
--header 'Authorization: {{AUTH_TOKEN}}'    
  
require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task?limit=3&offset=1")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
      
import requests

url = "https://app.desklog.io/api/v2/task?limit=3&offset=1"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
    
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/task?limit=3&offset=1', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task?limit=3&offset=1")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
  
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'GET',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task?limit=3&offset=1", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task?limit=3&offset=1"
    method := "GET"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/task?limit=3&offset=1");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                      
{
    "status": true,
    "message": "success",
    "data": [
        {
        "id": 648,
        "task_title": "test task anu - 10-4-25",
        "basic_status_id": 2,
        "current_status": "In Progress"
        },
        {
        "id": 647,
        "task_title": "test task amal - 10-4-25",
        "basic_status_id": 2,
        "current_status": "In Progress"
        },
        {
        "id": 646,
        "task_title": "test task Aishu Dilna - 10-4-25",
        "basic_status_id": 4,
        "current_status": "Completed"
        }
    ]
    }
  
                      
                  

                                            
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                      
                      
                    

                                            
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                      
                      
                    

Task Details

The task_show section allows users to retrieve detailed information about a specific task within the desklog project management system. By accessing this API endpoint, users can view key details such as task title, description, due date, priority, and assigned team members. This section provides a comprehensive view of individual tasks, aiding users in effectively managing their project workflow.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the request to access the task_show endpoint. It must contain a valid authentication token to authorize the user's access to the specific task.

Responses

200

Response Attributes

status boolean

message string

data object

task_title string

description string

project_id number

assigned_to number

reporter_id number

task_type_id number

priority_id number

priority string

current_status string

time_spend_in_sec number

time_allocated_sec number

time_allocated_pretty string

task_exceeded boolean

is_billable number

GET/api/v2/task/628

                    
curl --location 'https://app.desklog.io/api/v2/task/628' \
--header 'Authorization: {{AUTH_TOKEN}}'    
      
require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task/628")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
        
import requests

url = "https://app.desklog.io/api/v2/task/628"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
        
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/task/628', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
        
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task/628")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
      
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'GET',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task/628", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
      
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task/628"
    method := "GET"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
      
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/task/628");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500


{
"status": true,
"message": "success",
"data": {
    "task_title": "task hee",
    "description": "decfef",
    "project_id": 115,
    "assigned_to": 1,
    "reporter_id": 1,
    "task_type_id": 4,
    "priority_id": 2,
    "priority": "Intermediate",
    "current_status": "Fixed",
    "time_spend_in_sec": 86186,
    "time_allocated_sec": 600,
    "time_allocated_pretty": "00h 10m",
    "task_exceeded": true,
    "is_billable": 1
}
}

Task Create

The task_create section allows users to create a new task within the desklog project management system. With this API, users can easily add tasks, assign them to team members, set deadlines, and specify project details. This section streamlines the process of task creation, enhancing project organization and collaboration.

Header parameters

Authorization string

The authentication token used to verify the user's identity and permissions.

Body parameters

task_title string

The title or name of the task to be created.

assignee number

The user or team member assigned to the task for completion.

assigned_time number

The timestamp when the task was assigned to the assignee.

task_type number

The type or category of the task to classify its nature or purpose. normal >> 1, bug >> 4

is_billable number

Indicates whether the task is billable, used for tracking billable hours or services. 0 => non billable, 1 => billable

description string

A detailed description or information about the task to provide context and guidance.

priority_id number

The priority level assigned to the task, indicating its importance or urgency.

start_date string

The start date of the task, indicating when work on the task is scheduled to begin.

end_date string

The end date of the task, specifying when the task is expected to be completed.

project_id number

The unique identifier for the project to which the task belongs.

Responses

200

Response Attributes

status boolean

message string

data string

PATCH/api/v2/task

                            
curl --location 'https://app.desklog.io/api/v2/task' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
}'
          
          
                        

                      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
})

response = https.request(request)
puts response.read_body            
              
          
          
                            
                        

                                
import requests
import json

url = "https://app.desklog.io/api/v2/task"

payload = json.dumps({
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
            
            
          
          
          
                        

                                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/task', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
            
           
                                          
                        

                                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"task_title\": \"task here\",
\"assignee\": 10,
\"assigned_time\": 6600,
\"task_type\": 1,
\"is_billable\": 0,
\"description\": \"check\",
\"priority_id\": 3,
\"start_date\": \"2025-04-04\",
\"end_date\": \"2025-04-09\",
\"project_id\": 115
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
          
           
                        

                              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
});

var requestOptions = {
    method: 'POST',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
          
               
                        

                       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task"
    method := "POST"

    payload := strings.NewReader(`{
    "task_title": "task here",
    "assignee": 10,
    "assigned_time": 6600,
    "task_type": 1,
    "is_billable": 0,
    "description": "check",
    "priority_id": 3,
    "start_date": "2025-04-04",
    "end_date": "2025-04-09",
    "project_id": 115
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
          
           
                        

                                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/task");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"task_title\": \"task here\",
    \"assignee\": 10,
    \"assigned_time\": 6600,
    \"task_type\": 1,
    \"is_billable\": 0,
    \"description\": \"check\",
    \"priority_id\": 3,
    \"start_date\": \"2025-04-04\",
    \"end_date\": \"2025-04-09\",
    \"project_id\": 115
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
       
          
                          
                        

Response

200 400 500

                              
{
    "status": true,
    "message": "Task added successfully, but the assigned time has been set to zero as it exceeds the project's allocated time.",
    "data": {
        "task_id": 125
    }
}
          
    {
        "status": false,
        "message": "Error message",
        "data": {}
        }
                              
        {
            "status": false,
            "message": "Error message",
            "data": {}
            }

Task Delete

The task_delete section allows users to remove a specific task from a project within the desklog API. By utilizing this section, users can efficiently manage their project tasks and maintain an organized workflow by deleting unnecessary or completed tasks as needed.

Header parameters

Authorization string

This header parameter is used to authenticate the request and provide authorization to access the DELETE endpoint for deleting a task with the specified ID.

Responses

200

Response Attributes

status boolean

message string

data string

DELETE/api/v2/task/633

                                    
curl --location --request DELETE 'https://app.desklog.io/api/v2/task/633' \
--header 'Authorization: {{AUTH_TOKEN}}'
              
require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task/633")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
                
import requests

url = "https://app.desklog.io/api/v2/task/633"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
                
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('DELETE', 'https://app.desklog.io/api/v2/task/633', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task/633")
.method("DELETE", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'DELETE',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task/633", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
              
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task/633"
    method := "DELETE"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
              
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://app.desklog.io/api/v2/task/633");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                                  
{
    "status": true,
    "message": "Task deleted successfully",
    "data": null
    }
              
{
    "status": false,
    "message": "Something went wrong",
    "data": null
    }
                                  
{
    "status": false,
    "message": "Error message",
    "data": {}
    }

Task Update

The task_update section allows users to update specific details of a task within the desklog project management system. With this API, users can effortlessly modify task attributes such as status, due date, priority, and assignee information. Enhance your project management workflow by seamlessly managing and updating individual tasks with ease.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the API request.

Body Parameters

task_title string

priority string

assigned_to number

assigned_time number

description string

start_date string

end_date string

is_billable number

task_type number

Responses

200

Response Attributes

status boolean

message string

PATCH/api/v2/task/632

            
curl --location --request PATCH 'https://app.desklog.io/api/v2/task/632' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "task_title": "neema task",
    "priority": null,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
}'
  
  
                

      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task/632")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "task_title": "neema task",
    "priority": nil,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
})

response = https.request(request)
puts response.read_body
    
    
  
  
                    
                

                
import requests
import json

url = "https://app.desklog.io/api/v2/task/632"

payload = json.dumps({
    "task_title": "neema task",
    "priority": None,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("PATCH", url, headers=headers, data=payload)

print(response.text)
    
    
  
  
  
                

                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "task_title": "neema task",
    "priority": null,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
}';
$request = new Request('PATCH', 'https://app.desklog.io/api/v2/task/632', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();

   
                                  
                

                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"task_title\": \"neema task\",
\"priority\": null,
\"assigned_to\": 5,
\"assigned_time\": 6600,
\"description\": \"test tg\",
\"start_date\": \"2025-03-28\",
\"end_date\": \"2025-03-30\",
\"is_billable\": 1,
\"task_type\": 4
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task/632")
.method("PATCH", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
   
                

              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "task_title": "neema task",
    "priority": null,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
});

var requestOptions = {
    method: 'PATCH',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task/632", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
       
                

       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task/632"
    method := "PATCH"

    payload := strings.NewReader(`{
    "task_title": "neema task",
    "priority": null,
    "assigned_to": 5,
    "assigned_time": 6600,
    "description": "test tg",
    "start_date": "2025-03-28",
    "end_date": "2025-03-30",
    "is_billable": 1,
    "task_type": 4
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "https://app.desklog.io/api/v2/task/632");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"task_title\": \"neema task\",
    \"priority\": null,
    \"assigned_to\": 5,
    \"assigned_time\": 6600,
    \"description\": \"test tg\",
    \"start_date\": \"2025-03-28\",
    \"end_date\": \"2025-03-30\",
    \"is_billable\": 1,
    \"task_type\": 4
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
      
  
                  
                

Response

200 400 500

                      
{
    "status": true,
    "message": "Task updated successfully."
    }
  
{
"status": false,
"message": "Error message",
"data": {}
}
                      
{
"status": false,
"message": "Error message",
"data": {}
}

Task Status Change

The task_status_change section allows users to update the status of a specific task within the desklog project management system. By utilizing this API functionality, users can easily manage and track the progress of individual tasks, improving overall project efficiency and organization.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the API request. It typically contains the access token or API key required to access the endpoint securely.

Body Parameters

task_id number

The task_id parameter uniquely identifies the task for which the status change is requested. This parameter is required for the task_status_change endpoint.

status string

The status parameter specifies the new status to be assigned to the task. This parameter is required for the task_status_change endpoint. status => start,pause,stop

Responses

200

Response Attributes

basic_status number

message string

data object

id number

tag string

GET/api/v2/task_tag?limit=20&offset=0

            
curl --location 'https://app.desklog.io/api/v2/task_tag?limit=20&offset=0' \
--header 'Authorization: {{AUTH_TOKEN}}'
  
require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task_tag?limit=20&offset=0")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
    
import requests

url = "https://app.desklog.io/api/v2/task_tag?limit=20&offset=0"

payload = {}
headers = {
'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
                   
$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/task_tag?limit=20&offset=0', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task_tag?limit=20&offset=0")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
  
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
method: 'GET',
headers: myHeaders,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task_tag?limit=20&offset=0", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
  
package main

import (
"fmt"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/task_tag?limit=20&offset=0"
method := "GET"

client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)

if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
  
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/task_tag?limit=20&offset=0");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                      
{
"status": true,
"message": "success.",
"data": [
{
"id": 7,
"tag": "black"
},
{
"id": 103,
"tag": "dflkgtdrseawsedrftgi"
},
{
"id": 101,
"tag": "esde"
},
{
"id": 102,
"tag": "new tag"
}
]
}
  
                      
                  

                                            
{
"status": false,
"message": "Error message",
"data": {}
}
                      
                      
                    

                                            
{
"status": false,
"message": "Error message",
"data": {}
}
                      
                      
                    

Task Priority

Header Parameters

Authorization string

Query Parameters

limit string

offset string

GET/api/v2/priority?limit=10&offset=0

        
curl --location 'https://app.desklog.io/api/v2/priority?limit=10&offset=0' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json'


              


require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/priority?limit=10&offset=0")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"

response = https.request(request)
puts response.read_body    


                  
              


import requests
import json

url = "https://app.desklog.io/api/v2/priority?limit=10&offset=0"

payload = {}
headers = {
'Authorization': '{{AUTH_TOKEN}}',
'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)



              


$client = new Client();
$headers = [
'Authorization' => '{{AUTH_TOKEN}}',
'Content-Type' => 'application/json'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/priority?limit=10&offset=0', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
 
                                
              


OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/priority?limit=10&offset=0")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();

 
              


var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var requestOptions = {
method: 'GET',
headers: myHeaders,
redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/priority?limit=10&offset=0", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

     
              


package main

import (
"fmt"
"net/http"
"io/ioutil"
)

func main() {

url := "https://app.desklog.io/api/v2/priority?limit=10&offset=0"
method := "GET"

client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)

if err != nil {
  fmt.Println(err)
  return
}
req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
req.Header.Add("Content-Type", "application/json")

res, err := client.Do(req)
if err != nil {
  fmt.Println(err)
  return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
  fmt.Println(err)
  return
}
fmt.Println(string(body))
}

 
              

             
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/priority?limit=10&offset=0");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
   

                
              

Tag List

The list_task_tag section allows users to retrieve a list of task tags associated with projects and tasks. By accessing this section, users can easily categorize and organize their tasks based on different tags, helping them streamline and prioritize their project management efforts effectively.

Header parameters

Authorization string

Contains the authentication credentials required to access the API endpoint securely.

Query Parameters

limit string

Specifies the maximum number of task tags to return in the response. Default value is 10.

offset string

Specifies the number of task tags to skip before starting to return them in the response. Default value is 0.

Responses

200

Response Attributes

basic_status number

self_task number

message string

POST/api/v2/task_status_change

                                            
curl --location 'https://app.desklog.io/api/v2/task_status_change' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "task_id": 623,
    "status": "start"
}'
                  
                  
                                

                                      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task_status_change")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "task_id": 623,
    "status": "start"
})

response = https.request(request)
puts response.read_body
                    
                    
                  
                  
                                    
                                

                                                
import requests
import json

url = "https://app.desklog.io/api/v2/task_status_change"

payload = json.dumps({
    "task_id": 623,
    "status": "start"
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
                    
                    
                    
                  
                  
                  
                                

                                                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "task_id": 623,
    "status": "start"
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/task_status_change', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
                    
    
                   
                                                  
                                

                                                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"task_id\": 623,
\"status\": \"start\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task_status_change")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
                  
                   
                                

                                              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "task_id": 623,
    "status": "start"
});

var requestOptions = {
    method: 'POST',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task_status_change", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
                  
                       
                                

                                       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task_status_change"
    method := "POST"

    payload := strings.NewReader(`{
    "task_id": 623,
    "status": "start"
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
                  
                   
                                

                                                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/task_status_change");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"task_id\": 623,
    \"status\": \"start\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
                    
                    
                  
                                  
                                

Response

200 400 500

                                      
{
    "basic_status": 2,
    "self_task": null,
    "message": "Task Status Updated"
    }
                  
{
    "status": false,
    "message": "Error message",
    "data": {}
    }
                                      
    {
        "status": false,
        "message": "Error message",
        "data": {}
        }

Tag Add

The "add_task_tag" section in the desklog API allows users to assign tags to tasks within a project. By using this feature, users can organize and categorize tasks more effectively, enabling better tracking and management of project activities. This functionality enhances task management capabilities and streamlines project workflow for improved productivity.

Header parameters

Authorization string

The Authorization header parameter contains the access token used for authentication to authorize the API request.

Body Parameters

name string

The name parameter specifies the name of the task tag to be added

Responses

200

Response Attributes

status number

message string

POST/api/v2/task_tag

            
curl --location 'https://app.desklog.io/api/v2/task_tag' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "name": "new test tag"
}'
  
  
                

      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task_tag")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "name": "new test tag"
})

response = https.request(request)
puts response.read_body
     
  
  
                    
                

                
import requests
import json

url = "https://app.desklog.io/api/v2/task_tag"

payload = json.dumps({
    "name": "new test tag"
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
    
  
  
  
                

                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "name": "new test tag"
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/task_tag', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
   
                                  
                

                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"name\": \"new test tag\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task_tag")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
   
                

              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "name": "new test tag"
});

var requestOptions = {
    method: 'POST',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task_tag", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
       
                

       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task_tag"
    method := "POST"

    payload := strings.NewReader(`{
    "name": "new test tag"
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/task_tag");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"name\": \"new test tag\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
         
  
                  
                

Response

200 400 500

                      
{
    "status": false,
    "message": "Entered tag already exist"
	"data": {
          "tag_id": 142
     }
}
  
{
"status": false,
"message": "Error message",
"data": {}
}
                      
{
"status": false,
"message": "Error message",
"data": {}
}

Tag Edit

The edit_task_tag section allows users to modify the tags associated with a specific task within the desklog project management system. By utilizing this functionality, users can update and customize task tags to improve organization and workflow efficiency within their projects. This section empowers users to tailor task tags to suit their specific project needs and enhance overall task management capabilities.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the request to perform the editing of the task tag with ID 103.

Body Parameters

name string

The name parameter specifies the new name to be assigned to the task tag with the ID 103.

Responses

200

Response Attributes

status boolean

message string

PATCH/api/v2/task_tag/103

                    
curl --location --request PATCH 'https://app.desklog.io/api/v2/task_tag/103' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data '{
    "name": "dflkgtdrseawsedrftgi"
}'
      
      
                    

              
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task_tag/103")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "name": "dflkgtdrseawsedrftgi"
})

response = https.request(request)
puts response.read_body
          
      
      
                        
                    

                        
import requests
import json

url = "https://app.desklog.io/api/v2/task_tag/103"

payload = json.dumps({
    "name": "dflkgtdrseawsedrftgi"
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("PATCH", url, headers=headers, data=payload)

print(response.text)
           
      
      
      
                    

                           
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "name": "dflkgtdrseawsedrftgi"
}';
$request = new Request('PATCH', 'https://app.desklog.io/api/v2/task_tag/103', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
        
       
                                      
                    

                           
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"name\": \"dflkgtdrseawsedrftgi\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task_tag/103")
.method("PATCH", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
      
       
                    

                      
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "name": "dflkgtdrseawsedrftgi"
});

var requestOptions = {
    method: 'PATCH',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task_tag/103", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
      
           
                    

               
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task_tag/103"
    method := "PATCH"

    payload := strings.NewReader(`{
    "name": "dflkgtdrseawsedrftgi"
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
      
       
                    

                         
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "https://app.desklog.io/api/v2/task_tag/103");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"name\": \"dflkgtdrseawsedrftgi\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
        
             
      
                      
                    

Response

200 400 500

                          
{
    "status": true,
    "message": "Tag name edited successfully."
    }
      
    {
    "status": false,
    "message": "Error message",
    "data": {}
    }
                          
    {
    "status": false,
    "message": "Error message",
    "data": {}
    }

Tag Delete

The delete_task_tag section allows users to remove a specific tag associated with a task within the desklog project management system. By utilizing this API functionality, users can efficiently manage and organize task tags, streamlining their workflow and improving project organization.

Header parameters

Authorization string

A header parameter used for authentication and authorization purposes. It contains the access token or API key required to access the specified endpoint.

Responses

200

Response Attributes

status boolean

message string

DELETE/api/v2/task_tag/104

                            
curl --location --request DELETE 'https://app.desklog.io/api/v2/task_tag/104' \
--header 'Authorization: {{AUTH_TOKEN}}'

require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/task_tag/104")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
            
import requests

url = "https://app.desklog.io/api/v2/task_tag/104"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
            
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('DELETE', 'https://app.desklog.io/api/v2/task_tag/104', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/task_tag/104")
.method("DELETE", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
          
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'DELETE',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/task_tag/104", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
          
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/task_tag/104"
    method := "DELETE"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
          
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://app.desklog.io/api/v2/task_tag/104");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                              
{
    "status": true,
    "message": "Tag deleted successfully."
    }
          
{
"status": false,
"message": "Error message",
"data": {}
}
                              
{
"status": false,
"message": "Error message",
"data": {}
}

Client List

The client_list section allows users to retrieve a list of clients associated with their projects and tasks within the desklog platform. This API section provides users with the ability to access and manage client information, facilitating efficient organization and tracking of project stakeholders. By utilizing this section, users can easily view and interact with client data to streamline project management processes.

Header parameters

Authorization string

A security token that authorizes the request to access client information.

Query parameters

limit string

Specifies the maximum number of clients to return in the response.

offset string

Indicates the starting point within the list of clients to retrieve data from.

Responses

200

Response Attributes

status boolean

message string

data object

id number

first_name string

email string

GET/api/v2/client?limit=10&offset=0

                                    
curl --location 'https://app.desklog.io/api/v2/client?limit=10&offset=0' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json'
    
              
                            

                              
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/client?limit=10&offset=0")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"

response = https.request(request)
puts response.read_body
                
                
              
              
                                
                            

                                        
import requests
import json

url = "https://app.desklog.io/api/v2/client?limit=10&offset=0"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
                
              
              
              
                            

                                           
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$request = new Request('GET', 'https://app.desklog.io/api/v2/client?limit=10&offset=0', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();


    
               
                                              
                            

                                           
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/client?limit=10&offset=0")
.method("GET", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
              
               
                            

                                      
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var requestOptions = {
    method: 'GET',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/client?limit=10&offset=0", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
              
                   
                            

                               
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/client?limit=10&offset=0"
    method := "GET"

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, nil)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
              
               
                            

                                         
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://app.desklog.io/api/v2/client?limit=10&offset=0");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent(string.Empty);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
                
                
              
                              
                            

Response

200 400 500

                                  
{
    "status": true,
    "message": "success",
    "data": [
        {
        "id": 1,
        "first_name": "Adil",
        "email": "adil_cli@gmail.com"
        },
        {
        "id": 3,
        "first_name": "Pranav Govindq",
        "email": "pranav_cli@gmail.com"
        },
        {
        "id": 4,
        "first_name": "Ajay P",
        "email": "ajay_cli@gmail.com"
        }
    ]
    }
              
                                  
                              

                                                                    
{
"status": false,
"message": "Error message",
"data": {}
}
                                  
                                  
                                

                                                                    
{
"status": false,
"message": "Error message",
"data": {}
}
                                  
                                  
                                

Client Add

The "add_client" section allows users to create a new client within the desklog project management system. By using this API, users can easily add and manage client information for their projects, streamlining the workflow and organization of project tasks.

Header parameters

Authorization string

The authorization token required to authenticate and authorize the client API request.

Body parameters

name string

email string

address string

city string

state string

post_code string

country string

phone string

Responses

200

Response Attributes

status boolean

message string

data string

GET/api/v2/client

                                            
curl --location 'https://app.desklog.io/api/v2/client' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
}'
        
                  
                                

                                      
curl --location 'https://app.desklog.io/api/v2/client' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
}'     
                    
                  
                  
                                    
                                

                                                
import requests
import json

url = "https://app.desklog.io/api/v2/client"

payload = json.dumps({
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
                    
                    
                  
                  
                  
                                

                                                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
}';
$request = new Request('POST', 'https://app.desklog.io/api/v2/client', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
        
                   
                                                  
                                

                                                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"name\": \"client 114\",
\"email\": \"client124@gmail.com\",
\"address\": \"gyhwgdwhdg\",
\"city\": \"\",
\"state\": \"kerala\",
\"post_code\": \"6788887\",
\"country\": \"sdfce\",
\"phone\": \"899856586\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/client")
.method("POST", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
                  
                   
                                

                                              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
});

var requestOptions = {
    method: 'POST',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/client", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
                  
                       
                                

                                       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/client"
    method := "POST"

    payload := strings.NewReader(`{
    "name": "client 114",
    "email": "client124@gmail.com",
    "address": "gyhwgdwhdg",
    "city": "",
    "state": "kerala",
    "post_code": "6788887",
    "country": "sdfce",
    "phone": "899856586"
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
                  
                   
                                

                                                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://app.desklog.io/api/v2/client");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"name\": \"client 114\",
    \"email\": \"client124@gmail.com\",
    \"address\": \"gyhwgdwhdg\",
    \"city\": \"\",
    \"state\": \"kerala\",
    \"post_code\": \"6788887\",
    \"country\": \"sdfce\",
    \"phone\": \"899856586\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
                    
                  
                                  
                                

Response

200 400 500

                                      
{
    "status": true,
    "message": "Client added successfully",
    "data": {
        "client_id": 132
    }
}
                  
    {
    "status": false,
    "message": "Error message",
    "data": {}
    }
                                      
    {
    "status": false,
    "message": "Error message",
    "data": {}
    }

Client Update

The "update_client" section allows users to modify and update client information within the desklog project and tasks API. With this functionality, users can seamlessly update client details to ensure accurate and up-to-date project management.

Header parameters

Authorization string

The access token that authorizes the client to make changes to the specified client data.

Body parameters

name string

email string

address string

city string

state string

post_code string

country string

phone string

Responses

200

Response Attributes

status boolean

message string

data string

PATCH/api/v2/client/22

            
curl --location --request PATCH 'https://app.desklog.io/api/v2/client/22' \
--header 'Authorization: {{AUTH_TOKEN}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
}'

  
                

      
require "uri"
require "json"
require "net/http"

url = URI("https://app.desklog.io/api/v2/client/22")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
})

response = https.request(request)
puts response.read_body
     
  
  
                    
                

                
import requests
import json

url = "https://app.desklog.io/api/v2/client/22"

payload = json.dumps({
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
})
headers = {
    'Authorization': '{{AUTH_TOKEN}}',
    'Content-Type': 'application/json'
}

response = requests.request("PATCH", url, headers=headers, data=payload)

print(response.text)
      
  
  
  
                

                   
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}',
    'Content-Type' => 'application/json'
];
$body = '{
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
}';
$request = new Request('PATCH', 'https://app.desklog.io/api/v2/client/22', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
   
                                  
                

                   
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"name\": \"client ooo\",
\"email\": \"clien78e@gmail.com\",
\"address\": \"\",
\"city\": \"\",
\"state\": \"kerala\",
\"post_code\": \"454487\",
\"country\": \"sdfce\",
\"phone\": \"899856586\"
}");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/client/22")
.method("PATCH", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.addHeader("Content-Type", "application/json")
.build();
Response response = client.newCall(request).execute();
  
   
                

              
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");
myHeaders.append("Content-Type", "application/json");

var raw = JSON.stringify({
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
});

var requestOptions = {
    method: 'PATCH',
    headers: myHeaders,
    body: raw,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/client/22", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
       
                

       
package main

import (
    "fmt"
    "strings"
    "net/http"
    "io/ioutil"
)

func main() {

    url := "https://app.desklog.io/api/v2/client/22"
    method := "PATCH"

    payload := strings.NewReader(`{
    "name": "client ooo",
    "email": "clien78e@gmail.com",
    "address": "",
    "city": "",
    "state": "kerala",
    "post_code": "454487",
    "country": "sdfce",
    "phone": "899856586"
}`)

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
    fmt.Println(err)
    return
    }
    req.Header.Add("Authorization", "{{AUTH_TOKEN}}")
    req.Header.Add("Content-Type", "application/json")

    res, err := client.Do(req)
    if err != nil {
    fmt.Println(err)
    return
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
    fmt.Println(err)
    return
    }
    fmt.Println(string(body))
}
  
   
                

                 
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "https://app.desklog.io/api/v2/client/22");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var content = new StringContent("{
    \"name\": \"client ooo\",
    \"email\": \"clien78e@gmail.com\",
    \"address\": \"\",
    \"city\": \"\",
    \"state\": \"kerala\",
    \"post_code\": \"454487\",
    \"country\": \"sdfce\",
    \"phone\": \"899856586\"
}", null, "application/json");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
    
  
                  
                

Response

200 400 500

                      
{
    "status": true,
    "message": "Client details updated successfully",
    "data": null
    }
  
{
"status": false,
"message": "Error message",
"data": {}
}
                      
{
"status": false,
"message": "Error message",
"data": {}
}

Client Delete

The delete_client section allows users to remove a client from the desklog project, freeing up resources and maintaining a clean database. By utilizing this feature, users can efficiently manage their client list and ensure accurate project tracking and reporting.

Header parameters

Authorization string

The Authorization header parameter is used to authenticate the client in order to access and delete the client information. It contains the access token or credentials required to authorize the client request.

Responses

200

Response Attributes

status boolean

message string

DELETE/api/v2/client/25

            
curl --location --request DELETE 'https://app.desklog.io/api/v2/client/25' \
--header 'Authorization: {{AUTH_TOKEN}}'

require "uri"
require "net/http"

url = URI("https://app.desklog.io/api/v2/client/25")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = "{{AUTH_TOKEN}}"

response = https.request(request)
puts response.read_body
    
import requests

url = "https://app.desklog.io/api/v2/client/25"

payload = {}
headers = {
    'Authorization': '{{AUTH_TOKEN}}'
}

response = requests.request("DELETE", url, headers=headers, data=payload)

print(response.text)
    
$client = new Client();
$headers = [
    'Authorization' => '{{AUTH_TOKEN}}'
];
$request = new Request('DELETE', 'https://app.desklog.io/api/v2/client/25', $headers);
$res = $client->sendAsync($request)->wait();
echo $res->getBody()->getContents();
    
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder()
.url("https://app.desklog.io/api/v2/client/25")
.method("DELETE", body)
.addHeader("Authorization", "{{AUTH_TOKEN}}")
.build();
Response response = client.newCall(request).execute();
  
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'DELETE',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/client/25", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
var myHeaders = new Headers();
myHeaders.append("Authorization", "{{AUTH_TOKEN}}");

var requestOptions = {
    method: 'DELETE',
    headers: myHeaders,
    redirect: 'follow'
};

fetch("https://app.desklog.io/api/v2/client/25", requestOptions)
    .then(response => response.text())
    .then(result => console.log(result))
    .catch(error => console.log('error', error));
  
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "https://app.desklog.io/api/v2/client/25");
request.Headers.Add("Authorization", "{{AUTH_TOKEN}}");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Response

200 400 500

                      
{
    "status": true,
    "message": "Client deleted"
    }
  
{
"status": false,
"message": "Error message",
"data": {}
}
                      
{
"status": false,
"message": "Error message",
"data": {}
}

API Documentation

Introduction

Authentication

Authentication Header Format:

API's

Base URL:

Ping

Responses

Response Attributes

User List

Header parameters

Body parameters

Responses

Response Attributes

Show child attributes

Response Attributes

Response Attributes

User Profile

Header parameters

Body parameters

Responses

Response Attributes

Show child attributes

Response Attributes

Response Attributes

User Profile Update

Header parameters

Body parameters

Responses

Response Attributes

Response Attributes

Response Attributes

User Register

Header parameters

Body parameters

Responses

Response Attributes

Response Attributes

Response Attributes

Team List

Header parameters

Responses

Response Attributes

Show child attributes

Response Attributes

Response Attributes

Team Details

Header parameters

Body parameters

Responses

Response Attributes

Show child attributes

Response Attributes

Response Attributes

Team Create

Header parameters

Body parameters

Responses

Response Attributes

Response Attributes

Response Attributes

Team Delete

Header parameters

Body parameters

Responses

Response Attributes

Response Attributes

Response Attributes

Rename Team

Header parameters

Body parameters

Responses

Response Attributes

Response Attributes

Response Attributes

Add Team Member

Header parameters

Body parameters

Responses

Response Attributes