Clients
GET List clients
https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients
List clients from workspace.
- cURL
- Go
- Ruby
- JavaScript
- Python
- Rust
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
Name | Type | Description |
---|---|---|
items | Array of object | - |
items
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_ext_id | string | The external ID of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_ext_type | string | The external type of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_provider | string | The provider (e.g. JIRA/SalesForce) that has an entity linked to this Toggl Track entity |
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
- Go
- Ruby
- JavaScript
- Python
- Rust
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_ext_id | string | The external ID of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_ext_type | string | The external type of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_provider | string | The provider (e.g. JIRA/SalesForce) that has an entity linked to this Toggl Track entity |
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
- Go
- Ruby
- JavaScript
- Python
- Rust
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_ext_id | string | The external ID of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_ext_type | string | The external type of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_provider | string | The provider (e.g. JIRA/SalesForce) that has an entity linked to this Toggl Track entity |
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
- Go
- Ruby
- JavaScript
- Python
- Rust
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_ext_id | string | The external ID of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_ext_type | string | The external type of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_provider | string | The provider (e.g. JIRA/SalesForce) that has an entity linked to this Toggl Track entity |
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
- Go
- Ruby
- JavaScript
- Python
- Rust
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
- Go
- Ruby
- JavaScript
- Python
- Rust
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
Name | Type | Description |
---|---|---|
items | Array of integer | - |
403
Forbidden
404
No client with ID {client_id} was found
500
Internal Server Error
POST Restores client and related projects.
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
- Go
- Ruby
- JavaScript
- Python
- Rust
curl -X POST https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/clients/{client_id}/restore \
-H "Content-Type: application/json" \
-d '\{"projects":[\{\}],"restore_all_projects":"boolean"\}' \
-u <email>:<password>
bytes, err := json.Marshal('\{"projects":[\{\}],"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":[\{\}],"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":[\{\}],"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":[\{\}],"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":[\{\}],"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_ext_id | string | The external ID of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_ext_type | string | The external type of the linked entity in the external system (e.g. JIRA/SalesForce) |
integration_provider | string | The provider (e.g. JIRA/SalesForce) that has an entity linked to this Toggl Track entity |
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