Clients

GET List clients

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients

List clients from workspace.

curl  https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients")
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/api/v9/workspaces/{workspace_id}/clients')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients", {
  method: "GET",
  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.get('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients', 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::GET, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace

Query

name	type	required	description
status	string	false	Use 'active' to only list active clients, 'archived' to only list archived clients and 'both' to retrieve active and archived clients. If not provided, only active clients are returned.
name	string	false	If provided, allows to filter by client name in a case insensitive manner, returning all the ones that contain the given string.

Response

200

Array of:

name	type	description
archived	boolean	IsArchived is true if the client is archived
at	string	When was the last update
creator_id	integer	CreatorID is the ID of the user who created the client
id	integer	Client ID
integration_provider	string	Integrations data
name	string	Name of the client
notes	string	-
permissions	string	List of authorization permissions for this client.
wid	integer	Workspace ID

400

Client status is invalid

403

Forbidden

500

Internal Server Error

POST Create client

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients

Create workspace client.

curl -X POST https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients \
  -H "Content-Type: application/json" \
  -d '{"name":"string","notes":"string","wid":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"name":"string","notes":"string","wid":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/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/api/v9/workspaces/{workspace_id}/clients')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"name":"string","notes":"string","wid":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients", {
  method: "POST",
  body: {"name":"string","notes":"string","wid":"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/api/v9/workspaces/{workspace_id}/clients', json={"name":"string","notes":"string","wid":"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/api/v9/workspaces/{workspace_id}/clients".to_string())
.json(&serde_json::json!({"name":"string","notes":"string","wid":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace

Body

name	type	description
name	string	Client name
notes	string	-
wid	integer	Workspace ID

Response

200

name	type	description
archived	boolean	IsArchived is true if the client is archived
at	string	When was the last update
creator_id	integer	CreatorID is the ID of the user who created the client
id	integer	Client ID
integration_provider	string	Integrations data
name	string	Name of the client
notes	string	-
permissions	string	List of authorization permissions for this client.
wid	integer	Workspace ID

400

Possible error messages:

* Client name maximum length is {max_client_length}
* Client name cannot be empty

403

Forbidden

500

Internal Server Error

GET Load client from ID

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}

Load client from workspace.

curl  https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id} \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}")
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/api/v9/workspaces/{workspace_id}/clients/{client_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}", {
  method: "GET",
  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.get('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}', 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::GET, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace
client_id	integer	true	Numeric ID of the client

Response

200

name	type	description
archived	boolean	IsArchived is true if the client is archived
at	string	When was the last update
creator_id	integer	CreatorID is the ID of the user who created the client
id	integer	Client ID
integration_provider	string	Integrations data
name	string	Name of the client
notes	string	-
permissions	string	List of authorization permissions for this client.
wid	integer	Workspace ID

403

Forbidden

404

No client with ID {client_id} was found

500

Internal Server Error

PUT Change client

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}

Update workspace client.

Note: use /workspaces/{workspace_id}/clients/{client_id}/archive to archive the client and /workspaces/{workspace_id}/clients/{client_id}/restore to restore it.

curl -X PUT https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id} \
  -H "Content-Type: application/json" \
  -d '{"name":"string","notes":"string","wid":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"name":"string","notes":"string","wid":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}", 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/api/v9/workspaces/{workspace_id}/clients/{client_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"name":"string","notes":"string","wid":"integer"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}", {
  method: "PUT",
  body: {"name":"string","notes":"string","wid":"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.put('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}', json={"name":"string","notes":"string","wid":"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::PUT, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}".to_string())
.json(&serde_json::json!({"name":"string","notes":"string","wid":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace
client_id	integer	true	Numeric ID of the client

Body

name	type	description
name	string	Client name
notes	string	-
wid	integer	Workspace ID

Response

200

name	type	description
archived	boolean	IsArchived is true if the client is archived
at	string	When was the last update
creator_id	integer	CreatorID is the ID of the user who created the client
id	integer	Client ID
integration_provider	string	Integrations data
name	string	Name of the client
notes	string	-
permissions	string	List of authorization permissions for this client.
wid	integer	Workspace ID

400

Possible error messages:

* Client name maximum length is {max_client_length}
* Client name cannot be empty

403

Forbidden

404

Client doesn't exist in the workspace.

500

Internal Server Error

DELETE Delete client

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}

Delete workspace client.

curl -X DELETE https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id} \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}")
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/api/v9/workspaces/{workspace_id}/clients/{client_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Delete.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}", {
  method: "DELETE",
  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.delete('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}', 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::DELETE, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace
client_id	integer	true	Numeric ID of the client

Response

200

Successful operation.

403

Forbidden

404

No client with ID {client_id} was found

500

Internal Server Error

POST Archives client

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive

Archives a workspace client and related projects. Only for premium workspaces.

curl -X POST https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive")
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/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive", {
  method: "POST",
  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/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive', 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/api/v9/workspaces/{workspace_id}/clients/{client_id}/archive".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace
client_id	integer	true	Numeric ID of the client

Response

200

Projects that were archived with the client

Array of:

403

Forbidden

404

No client with ID {client_id} was found

500

Internal Server Error

https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore

Restores client and all related or specified projects from the given workspace.

curl -X POST https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore \
  -H "Content-Type: application/json" \
  -d '{"projects":["integer"],"restore_all_projects":"boolean"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"projects":["integer"],"restore_all_projects":"boolean"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore", 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/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"projects":["integer"],"restore_all_projects":"boolean"}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore", {
  method: "POST",
  body: {"projects":["integer"],"restore_all_projects":"boolean"},
  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/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore', json={"projects":["integer"],"restore_all_projects":"boolean"}, 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/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore".to_string())
.json(&serde_json::json!({"projects":["integer"],"restore_all_projects":"boolean"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
workspace_id	integer	true	Numeric ID of the workspace
client_id	integer	true	Numeric ID of the client

Body

name	type	description
projects	Array of integer	-
restore_all_projects	boolean	-

Response

200

Returns the restored client

name	type	description
archived	boolean	IsArchived is true if the client is archived
at	string	When was the last update
creator_id	integer	CreatorID is the ID of the user who created the client
id	integer	Client ID
integration_provider	string	Integrations data
name	string	Name of the client
notes	string	-
permissions	string	List of authorization permissions for this client.
wid	integer	Workspace ID

400

Bad Request

403

Forbidden

404

No client with ID {client_id} was found

500

Internal Server Error

GET List clients​

Parameters​

Path​

Query​

Response​

200​

400​

403​

500​

POST Create client​

Parameters​

Path​

Body​

Response​

200​

400​

403​

500​

GET Load client from ID​

Parameters​

Path​

Response​

200​

403​

404​

500​

PUT Change client​

Parameters​

Path​

Body​

Response​

200​

400​

403​

404​

500​

DELETE Delete client​

Parameters​

Path​

Response​

200​

403​

404​

500​

POST Archives client​

Parameters​

Path​

Response​

200​

403​

404​

500​

POST Restores client and related projects.​

Parameters​

Path​

Body​

Response​

200​

400​

403​

404​

500​

GET List clients

Parameters

Path

Query

Response

200

400

403

500

POST Create client

Parameters

Path

Body

Response

200

400

403

500

GET Load client from ID

Parameters

Path

Response

200

403

404

500

PUT Change client

Parameters

Path

Body

Response

200

400

403

404

500

DELETE Delete client

Parameters

Path

Response

200

403

404

500

POST Archives client

Parameters

Path

Response

200

403

404

500

POST Restores client and related projects.

Parameters

Path

Body

Response

200

400

403

404

500