Organization

POST Create organization group

https://focus.toggl.com/api/organizations/{organization_id}/groups

Creates a group under an organization for the given users and workspaces.

cURL

curl -X POST https://focus.toggl.com/api/organizations/{organization_id}/groups \
  -H "Content-Type: application/json" \
  -d '\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}' \
  -u <email>:<password>

Go

bytes, err := json.Marshal('\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://focus.toggl.com/api/organizations/{organization_id}/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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/groups')
req = Net::HTTP::Post.new(uri)
req['Content-Type'] = "application/json"
req.body = \{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}.to_json
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/groups", {
  method: "POST",
  body: \{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\},
  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));

Python

import requests
from base64 import b64encode

data = requests.post('https://focus.toggl.com/api/organizations/{organization_id}/groups', json=\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/groups".to_string())
.json(&serde_json::json!(\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID

Body

Name	Type	Description
emoji	string	-
name	string	-
organization_users	Array of integer	-
workspaces	Array of integer	-

Response

201

Successful operation

400

Invalid request

403

User does not have access

500

Server error

GET Get current user's groups

https://focus.toggl.com/api/organizations/{organization_id}/groups/me

Get groups the current user belongs to

cURL

curl  https://focus.toggl.com/api/organizations/{organization_id}/groups/me \
  -H "Content-Type: application/json" \
  -u <email>:<password>

Go

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/groups/me")
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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/groups/me')
req = Net::HTTP::Get.new(uri)
req['Content-Type'] = "application/json"
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/groups/me", {
  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));

Python

import requests
from base64 import b64encode

data = requests.get('https://focus.toggl.com/api/organizations/{organization_id}/groups/me', headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/groups/me".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
emoji	string	-
id	integer	-
name	string	-

400

Invalid request

403

User does not have access to the organization

500

Server error

PUT Update organization group

https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}

Updates a group under an organization.

cURL

curl -X PUT https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id} \
  -H "Content-Type: application/json" \
  -d '\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}' \
  -u <email>:<password>

Go

bytes, err := json.Marshal('\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}')
req = Net::HTTP::Put.new(uri)
req['Content-Type'] = "application/json"
req.body = \{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}.to_json
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}", {
  method: "PUT",
  body: \{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\},
  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));

Python

import requests
from base64 import b64encode

data = requests.put('https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}', json=\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}, headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}".to_string())
.json(&serde_json::json!(\{"emoji":"string","name":"string","organization_users":[\{\}],"workspaces":[\{\}]\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
group_id	integer	true	group ID

Body

Name	Type	Description
emoji	string	-
name	string	-
organization_users	Array of integer	-
workspaces	Array of integer	-

Response

200

Name	Type	Description
created_at	string	-
deleted_at	string	-
emoji	string	-
id	integer	-
name	string	-
organization_id	integer	-
updated_at	string	-
users	Array of object	-
workspaces	Array of object	-

users

Name	Type	Description
created_at	string	-
deleted_at	string	-
display_name	string	-
focus_role_id	integer	-
organization_user_id	integer	-
track_role_id	integer	-
updated_at	string	-
user_account_id	integer	-
user_group_id	integer	-
work_role_id	integer	-

workspaces

Name	Type	Description
created_at	string	-
deleted_at	string	-
focus_role_id	integer	-
name	string	-
products	Array of string	-
updated_at	string	-
workspace_group_id	integer	-
workspace_id	integer	-

400

Invalid request

403

User does not have access

404

Group not found

500

Server error

DELETE Delete organization group

https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}

Deletes a group from an organization.

cURL

curl -X DELETE https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id} \
  -H "Content-Type: application/json" \
  -u <email>:<password>

Go

req, err := http.NewRequest(http.MethodPut, 
  "https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}')
req = Net::HTTP::Delete.new(uri)
req['Content-Type'] = "application/json"
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_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));

Python

import requests
from base64 import b64encode

data = requests.delete('https://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}', headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/groups/{group_id}".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
group_id	integer	true	group ID

Query

name	type	required	description
workspace_id	integer	true	workspace ID (required for permission check)

Response

200

Successful operation

400

Invalid request

403

User does not have access

404

Group not found

500

Server error

GET Get organization roles

https://focus.toggl.com/api/organizations/{organization_id}/roles

Get organization roles

cURL

curl  https://focus.toggl.com/api/organizations/{organization_id}/roles \
  -H "Content-Type: application/json" \
  -u <email>:<password>

Go

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/roles")
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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/roles')
req = Net::HTTP::Get.new(uri)
req['Content-Type'] = "application/json"
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/roles", {
  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));

Python

import requests
from base64 import b64encode

data = requests.get('https://focus.toggl.com/api/organizations/{organization_id}/roles', headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/roles".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
code	string	-
default_for_levels	Array of string	DefaultForLevels lists every level this role is the default at, and is nil when it is not one — never an empty list, which the stored column rejects.
description	string	-
entity	string	Valid values: organization, workspace, project, group.
name	string	-
organization_id	integer	-
permissions	Array of object	-
privilege_level	integer	-
require_group	boolean	RequireGroup is true when the role is only conferred through a group, whatever Entity says. Its permissions still cover Entity — a team role's cover the workspace — so a caller listing the roles assignable directly at an entity has to drop the ones that carry it, while a caller listing what a team can confer does not.
role_id	integer	-
type	string	Valid values: owner, admin, manager, guest.

permissions

Name	Type	Description
category_id	integer	-
category_name	string	-
condition	string	-
description	string	-
entity	string	Valid values: organization, workspace, project, group.
name	string	-
permission_id	integer	-

400

Invalid request

403

User does not have access to the organization

500

Server error

GET Get organization teams.

https://focus.toggl.com/api/organizations/{organization_id}/teams

Gets groups for a workspace, checking view_user_groups permission.

cURL

curl  https://focus.toggl.com/api/organizations/{organization_id}/teams \
  -H "Content-Type: application/json" \
  -u <email>:<password>

Go

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/teams")
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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/teams')
req = Net::HTTP::Get.new(uri)
req['Content-Type'] = "application/json"
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/teams", {
  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));

Python

import requests
from base64 import b64encode

data = requests.get('https://focus.toggl.com/api/organizations/{organization_id}/teams', headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/teams".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID

Query

name	type	required	description
workspace_id	integer	true	workspace ID (required for permission check)
page	integer	false	page number
per_page	integer	false	results per page
sort_dir	string	false	Direction to sort by (asc/desc)
filter	string	false	Filter by name
query	string	false	Filter by team name and its members' names
organization_user_id	integer	false	Filter groups that contain this organization user
group_ids	[]integer	false	Filter by group IDs
active_members_only	boolean	false	Filter by active members only

Response

200

Name	Type	Description
data	Array of object	-
page	integer	-
per_page	integer	-
total	integer	-

data

Name	Type	Description
created_at	string	-
deleted_at	string	-
emoji	string	-
id	integer	-
name	string	-
organization_id	integer	-
updated_at	string	-
users	Array of object	-
workspaces	Array of object	-

users

Name	Type	Description
created_at	string	-
deleted_at	string	-
display_name	string	-
focus_role_id	integer	-
organization_user_id	integer	-
track_role_id	integer	-
updated_at	string	-
user_account_id	integer	-
user_group_id	integer	-
work_role_id	integer	-

workspaces

Name	Type	Description
created_at	string	-
deleted_at	string	-
focus_role_id	integer	-
name	string	-
products	Array of string	-
updated_at	string	-
workspace_group_id	integer	-
workspace_id	integer	-

400

Invalid request

403

User does not have permission to view groups

500

Server error

GET Get organization users

https://focus.toggl.com/api/organizations/{organization_id}/users

Proxies to accounts organization users endpoint with guest scoping. Guests only see users who share projects with them.

cURL

curl  https://focus.toggl.com/api/organizations/{organization_id}/users \
  -H "Content-Type: application/json" \
  -u <email>:<password>

Go

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/users")
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))

Ruby

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

uri = URI('https://focus.toggl.com/api/organizations/{organization_id}/users')
req = Net::HTTP::Get.new(uri)
req['Content-Type'] = "application/json"
req.basic_auth '<email>', '<password>'
res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(req)
end
puts JSON.parse(res.body)

JavaScript

fetch("https://focus.toggl.com/api/organizations/{organization_id}/users", {
  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));

Python

import requests
from base64 import b64encode

data = requests.get('https://focus.toggl.com/api/organizations/{organization_id}/users', headers={'content-type': 'application/json', 'Authorization' : 'Basic %s' %  b64encode(b"<email>:<password>").decode("ascii")})
print(data.json())

Rust

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://focus.toggl.com/api/organizations/{organization_id}/users".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID

Query

name	type	required	description
workspaces	[]integer	false	Filter by workspace IDs
user_account_ids	[]integer	false	Filter by user account IDs
org_user_ids	[]integer	false	Filter by organization user IDs
groups	[]integer	false	Filter by group IDs
toggl_products	[]string	false	Filter by toggl products
active_status	[]string	false	Filter by active status
roles	[]integer	false	Filter by roles
only_admins	boolean	false	Only return admins
filter	string	false	Filter by name or email
sort_dir	string	false	Sort direction (asc/desc)
page	integer	false	Page number
per_page	integer	false	Results per page
tag_ids	[]integer	false	Filter by tag IDs
include_working_hours	boolean	false	Include working hours in response
include_rates	boolean	false	Include user rates data for each user
pinned_ids	[]integer	false	Pin specific users at the top (respects array order)
has_group	boolean	false	Filters users that do or do not belong to a team
cf_filter	[]string	false	Filter members by user custom-field values, fieldID:value entries ANDed together; requires workspaces to name exactly one workspace
include_custom_fields	boolean	false	Include each member's user custom-field values; requires workspaces to name exactly one workspace
include_calendar_integration	boolean	false	Include whether each member has a calendar integration connected. Requires the workspaces param to name exactly one workspace and the view_external_calendar_integrations permission on it

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
2fa_enabled	boolean	-
account_locked_at	string	-
accounts_role_id	integer	-
active	boolean	-
can_edit_personal_details	boolean	-
created_at	string	-
custom_field_values	Array of object	CustomFieldValues carries the member's user-level custom-field values. Present only when the list is called with include_custom_fields=true on a single workspace and the caller holds view_workspace_user_custom_fields with the beta enabled; omitted otherwise. Kept on this type (rather than a separate response type) so the generated client's OrganizationUserResponse keeps its name — FE code imports it directly.
deleted_at	string	-
email	string	-
groups	Array of object	-
has_calendar_integration	boolean	HasCalendarIntegration is true when the member has a calendar connected in Focus. The field is present only when the request sets include_calendar_integration to true and the calendar lookup succeeded. The field is absent when the lookup failed. Absent means unknown. It does not mean false. A member who connected a calendar in another product stays false here until they open the Focus calendar integrations page.
id	integer	-
invite_sent	boolean	-
joined	boolean	-
name	string	-
organization_id	integer	-
owner	boolean	-
permissions	object	-
rate	object	-
tags	Array of object	-
updated_at	string	-
user_account_id	integer	-
user_id	string	-
working_hours	number	-
workspaces	Array of object	-

custom_field_values

Name	Type	Description
custom_field_id	integer	-
custom_field_name	string	-
field_type	string	-
selected_options	Array of object	-
value	object	-

selected_options

Name	Type	Description
is_deleted	boolean	-
option_id	integer	-
option_name	string	-

groups

Name	Type	Description
emoji	string	-
id	integer	-
name	string	-
workspace_ids	Array of integer	-

permissions

rate

Name	Type	Description
currency	string	-
end_at	string	-
hourly_rate	number	-
start_at	string	-
workspace_id	integer	-
workspace_rate_id	integer	-
workspace_user_rate_id	integer	-

tags

Name	Type	Description
color	string	-
id	integer	-
label	string	-

workspaces

Name	Type	Description
focus_role_id	integer	-
groups	Array of object	-
id	integer	-
name	string	-
toggl_products	Array of string	-
track_role_id	integer	-
work_role_id	integer	-
workspace_user_id	integer	-

groups

Name	Type	Description
emoji	string	-
id	integer	-
name	string	-

400

Invalid request

403

User does not have access to the organization

422

cf_filter matches too many members; narrow the filter

500

Server error