Utils

POST List clients

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients

Returns filtered clients from a workspace (only ID and name).

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients \
  -H "Content-Type: application/json" \
  -d '{"ids":["integer"],"name":"string","start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"ids":["integer"],"name":"string","start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"ids":["integer"],"name":"string","start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients", {
  method: "POST",
  body: {"ids":["integer"],"name":"string","start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients', json={"ids":["integer"],"name":"string","start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/clients".to_string())
.json(&serde_json::json!({"ids":["integer"],"name":"string","start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
ids	Array of integer	-
name	string	-
start	integer	-

Response

200

Returns filtered clients

Array of:

name	type	description
id	integer	-
name	string	-

400

Maximum count of posted IDs is 2000

403

Workspace not found/accessible

500

Internal Server Error

POST List project groups filter

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups

Returns the project groups from a workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups \
  -H "Content-Type: application/json" \
  -d '{"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups", {
  method: "POST",
  body: {"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups', json={"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_groups".to_string())
.json(&serde_json::json!({"group_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
group_ids	Array of integer	Group IDs, optional. At least Projects IDs or Group IDs should be informed.
project_ids	Array of integer	Project IDs, optional. At least Projects IDs or Group IDs should be informed.
start_id	integer	-

Response

200

Returns project groups

Array of:

name	type	description
group_id	integer	-
id	integer	-
name	string	-
project_id	integer	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is {value}

403

Workspace not found/accessible

500

Internal Server Error

POST List project users

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users

Returns filtered user projects.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users \
  -H "Content-Type: application/json" \
  -d '{"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users", {
  method: "POST",
  body: {"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users', json={"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/project_users".to_string())
.json(&serde_json::json!({"client_ids":["integer"],"project_ids":["integer"],"start_id":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
client_ids	Array of integer	Client IDs, optional.
project_ids	Array of integer	Project IDs, optional.
start_id	integer	-

Response

200

Returns user projects

Array of:

name	type	description
group_id	integer	-
hourly_rate	number	-
id	integer	-
labour_cost	integer	-
manager	boolean	-
project_id	integer	-
user_id	integer	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is {value}

403

Workspace not found/accessible

500

Internal Server Error

POST List projects

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects

Returns filtered projects from a workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects \
  -H "Content-Type: application/json" \
  -d '{"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects", {
  method: "POST",
  body: {"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects', json={"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects".to_string())
.json(&serde_json::json!({"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
client_ids	Array of integer	Client IDs, optional.
currency	string	Currency, optional, example "EUR".
ids	Array of integer	Project IDs, optional.
is_active	boolean	Whether the wanted projects are archived, optional, default false.
is_billable	boolean	Whether the wanted projects are billable, optional, premium feature, default false.
is_private	boolean	Whether the wanted projects are private, optional, default false.
name	string	Project name, optional.
page_size	integer	PageSize is the number of records returned per page. If unset, the default value of 201 will be used.
start	integer	Start is used for pagination, optional, default 0. The api will return the next projects page with id >= Start.

Response

200

Returns filtered projects

Array of:

name	type	description
active	boolean	-
billable	boolean	-
client_id	integer	-
color	string	-
currency	string	-
id	integer	-
name	string	-

400

Maximum count of posted IDs is {value}

403

Workspace not found/accessible

500

Internal Server Error

POST List projects statuses

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status

Returns filtered projects statuses from a workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status \
  -H "Content-Type: application/json" \
  -d '{"active":"boolean","ids":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"active":"boolean","ids":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"active":"boolean","ids":["integer"]}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status", {
  method: "POST",
  body: {"active":"boolean","ids":["integer"]},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status', json={"active":"boolean","ids":["integer"]}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/projects/status".to_string())
.json(&serde_json::json!({"active":"boolean","ids":["integer"]}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
active	boolean	Whether the wanted projects statuses are archived, optional, default false.
ids	Array of integer	Project IDs.

Response

200

Returns projects statuses

Array of:

name	type	description
billable_amount	integer	-
billable_seconds	integer	-
currency	string	-
estimated_seconds	integer	-
id	integer	-
tracked_seconds	integer	-

403

Workspace not found/accessible

500

Internal Server Error

POST List tasks statuses

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status

Filter tasks statuses from a workspace

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status \
  -H "Content-Type: application/json" \
  -d '{"ids":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"ids":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"ids":["integer"]}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status", {
  method: "POST",
  body: {"ids":["integer"]},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status', json={"ids":["integer"]}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks/status".to_string())
.json(&serde_json::json!({"ids":["integer"]}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
ids	Array of integer	Time entries IDs.

Response

200

Returns filtered tasks

Array of:

name	type	description
billable_amount	integer	-
billable_seconds	integer	-
currency	string	-
estimated_seconds	integer	-
id	integer	-
tracked_seconds	integer	-

400

At least one parameter must be set

402

Tasks are a premium feature

403

Workspace not found/accessible

500

Internal Server Error

POST List tasks statuses

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status

Filter tasks statuses from a workspace

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status \
  -H "Content-Type: application/json" \
  -d '{"ids":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"ids":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"ids":["integer"]}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status", {
  method: "POST",
  body: {"ids":["integer"]},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status', json={"ids":["integer"]}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/tasks_auth/status".to_string())
.json(&serde_json::json!({"ids":["integer"]}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
ids	Array of integer	Time entries IDs.

Response

200

Returns filtered tasks

Array of:

name	type	description
billable_amount	integer	-
billable_seconds	integer	-
currency	string	-
estimated_seconds	integer	-
id	integer	-
tracked_seconds	integer	-

400

At least one parameter must be set

402

Tasks are a premium feature

403

Workspace not found/accessible

500

Internal Server Error

POST List users

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users

Returns filtered users from a workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users \
  -H "Content-Type: application/json" \
  -d '{"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users", {
  method: "POST",
  body: {"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users', json={"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/filters/users".to_string())
.json(&serde_json::json!({"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
active	boolean	Whether the wanted users are active, optional, default true.
admin	boolean	Whether the wanted users are admins, optional, default false.
ids	Array of integer	User IDs, optional.
start	integer	-

Response

200

Returns filtered users

Array of:

name	type	description
deleted_at	string	-
id	integer	-
name	string	-

400

Maximum count of posted IDs is 100

403

Workspace not found/accessible

500

Internal Server Error

POST Search clients

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients

Returns filtered clients from a workspace (whole client object).

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients \
  -H "Content-Type: application/json" \
  -d '{"ids":["integer"],"name":"string","start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"ids":["integer"],"name":"string","start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"ids":["integer"],"name":"string","start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients", {
  method: "POST",
  body: {"ids":["integer"],"name":"string","start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients', json={"ids":["integer"],"name":"string","start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/clients".to_string())
.json(&serde_json::json!({"ids":["integer"],"name":"string","start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
ids	Array of integer	-
name	string	-
start	integer	-

Response

200

Returns searched clients

Array of:

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is 2000

403

Workspace not found/accessible

500

Internal Server Error

POST List projects

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects

Returns filtered projects from a workspace (whole project object).

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects \
  -H "Content-Type: application/json" \
  -d '{"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects", {
  method: "POST",
  body: {"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects', json={"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/projects".to_string())
.json(&serde_json::json!({"client_ids":["integer"],"currency":"string","ids":["integer"],"is_active":"boolean","is_billable":"boolean","is_private":"boolean","name":"string","page_size":"integer","start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
client_ids	Array of integer	Client IDs, optional.
currency	string	Currency, optional, example "EUR".
ids	Array of integer	Project IDs, optional.
is_active	boolean	Whether the wanted projects are archived, optional, default false.
is_billable	boolean	Whether the wanted projects are billable, optional, premium feature, default false.
is_private	boolean	Whether the wanted projects are private, optional, default false.
name	string	Project name, optional.
page_size	integer	PageSize is the number of records returned per page. If unset, the default value of 201 will be used.
start	integer	Start is used for pagination, optional, default 0. The api will return the next projects page with id >= Start.

Response

200

Returns projects

Array of:

name	type	description
active	boolean	-
billable	boolean	-
client_id	integer	-
color	string	-
currency	string	-
id	integer	-
name	string	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is {value}

403

Workspace not found/accessible

500

Internal Server Error

POST List users

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users

Returns filtered users from a workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users \
  -H "Content-Type: application/json" \
  -d '{"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users", {
  method: "POST",
  body: {"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users', json={"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/search/users".to_string())
.json(&serde_json::json!({"active":"boolean","admin":"boolean","ids":["integer"],"start":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID

Body

name	type	description
active	boolean	Whether the wanted users are active, optional, default true.
admin	boolean	Whether the wanted users are admins, optional, default false.
ids	Array of integer	User IDs, optional.
start	integer	-

Response

200

Returns users

Array of:

name	type	description
deleted_at	string	-
id	integer	-
name	string	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is 100

403

Workspace not found/accessible

500

Internal Server Error

POST List tasks

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks

Returns filtered tasks from workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks \
  -H "Content-Type: application/json" \
  -d '{"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks", {
  method: "POST",
  body: {"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks', json={"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks".to_string())
.json(&serde_json::json!({"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID
action	string	true	search,filters

Body

name	type	description
active	boolean	-
ids	Array of integer	-
name	string	-
page_size	integer	-
project_active	boolean	-
project_ids	Array of integer	-
start	integer	-
user_ids	Array of integer	-

Response

200

Returns tasks

Array of:

name	type	description
active	boolean	-
at	string	-
estimated_seconds	integer \| null	-
id	integer	-
name	string	-
permissions	string	-
project_id	integer	-
recurring	boolean	-
server_deleted_at	string \| null	-
toggl_accounts_id	string \| null	-
tracked_seconds	integer	-
user_id	integer \| null	-
workspace_id	integer	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is 2000

403

Workspace not found/accessible

500

Internal Server Error

POST List tasks

https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth

Returns filtered tasks from workspace.

curl -X POST https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth \
  -H "Content-Type: application/json" \
  -d '{"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    print(err)
}

defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    print(err)
}

fmt.Print(string(body))

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth", {
  method: "POST",
  body: {"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]},
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth', json={"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::POST, "https://api.track.toggl.com/reports/api/v3/workspace/{workspace_id}/{action}/tasks_auth".to_string())
.json(&serde_json::json!({"active":"boolean","ids":["integer"],"name":"string","page_size":"integer","project_active":"boolean","project_ids":["integer"],"start":"integer","user_ids":["integer"]}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Workspace ID
action	string	true	search,filters

Body

name	type	description
active	boolean	-
ids	Array of integer	-
name	string	-
page_size	integer	-
project_active	boolean	-
project_ids	Array of integer	-
start	integer	-
user_ids	Array of integer	-

Response

200

Returns tasks

Array of:

name	type	description
active	boolean	-
at	string	-
estimated_seconds	integer \| null	-
id	integer	-
name	string	-
permissions	string	-
project_id	integer	-
recurring	boolean	-
server_deleted_at	string \| null	-
toggl_accounts_id	string \| null	-
tracked_seconds	integer	-
user_id	integer \| null	-
workspace_id	integer	-

400

Possible error messages:

* At least one parameter must be set
* Maximum count of posted IDs is 2000

403

Workspace not found/accessible

500

Internal Server Error

POST List clients​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

POST List project groups filter​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

POST List project users​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

POST List projects​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

POST List projects statuses​

Parameters​

Path​

Body​

Response​

200​

403​

500​

POST List tasks statuses​

Parameters​

Path​

Body​

Response​

200​

400​

402​

403​

500​

POST List tasks statuses​

Parameters​

Path​

Body​

Response​

200​

400​

402​

403​

500​

POST List users​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

POST Search clients​

Parameters​

Path​

Body​

Response​

200​

400​

POST List clients

Parameters

Path

Body

Response

200

400

403

500

POST List project groups filter

Parameters

Path

Body

Response

200

400

403

500

POST List project users

Parameters

Path

Body

Response

200

400

403

500

POST List projects

Parameters

Path

Body

Response

200

400

403

500

POST List projects statuses

Parameters

Path

Body

Response

200

403

500

POST List tasks statuses

Parameters

Path

Body

Response

200

400

402

403

500

POST List tasks statuses

Parameters

Path

Body

Response

200

400

402

403

500

POST List users

Parameters

Path

Body

Response

200

400

403

500

POST Search clients

Parameters

Path

Body

Response

200

400