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

GET/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();

                  

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

GET/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)

<?php
$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 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 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 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 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

GET/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"
    }
  ]
  }
                    