Groups

GET List of groups in organization with user and workspace assignments

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

Returns list of groups in organization based on set of url parameters. List is sorted by name.

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

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups")
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/organizations/{organization_id}/groups')
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/organizations/{organization_id}/groups", {
  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/organizations/{organization_id}/groups', 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/organizations/{organization_id}/groups".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	Numeric ID of the organization

Query

name	type	required	description
name	string	false	Returns records where name contains this string
workspace	string	false	ID of workspace. Returns groups assigned to this workspace

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
at	string	-
group_id	integer	-
name	string	-
permissions	Array of string	-
users	Array of object	-
workspaces	Array of integer	-

users

Name	Type	Description
avatar_url	string	-
inactive	boolean	-
joined	boolean	-
name	string	-
user_id	integer	-

400

Invalid number ...

POST Create group

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

Creates a group in the specified organization

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

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

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

uri = URI('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = \{"name":"string","users":[\{\}],"workspaces":[\{\}]\}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

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

import requests
from base64 import b64encode

data = requests.post('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups', json=\{"name":"string","users":[\{\}],"workspaces":[\{\}]\}, 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/organizations/{organization_id}/groups".to_string())
.json(&serde_json::json!(\{"name":"string","users":[\{\}],"workspaces":[\{\}]\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	Numeric ID of the organization.

Body

Name	Type	Description
name	string	Group name
users	Array of integer	Group users, optional
workspaces	Array of integer	Group workspaces

Response

200

Returns the created group data.

Name	Type	Description
at	string	-
group_id	integer	-
name	string	-
permissions	Array of string	-
users	Array of object	-
workspaces	Array of integer	-

users

Name	Type	Description
avatar_url	string	-
inactive	boolean	-
joined	boolean	-
name	string	-
user_id	integer	-

400

Possible error messages:

Invalid JSON input
Group name must be present
Group name too long, maximum length is 200
Name has already been taken
User {user} not exists in the organization {org}
Workspace {ws} not exists in the organization {org}

403

User does not have access to this resource

PUT Edit group

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

Edits a group in the specified organization

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

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

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

uri = URI('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_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","users":[\{\}],"workspaces":[\{\}]\}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

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

import requests
from base64 import b64encode

data = requests.put('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id}', json=\{"name":"string","users":[\{\}],"workspaces":[\{\}]\}, 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/organizations/{organization_id}/groups/{group_id}".to_string())
.json(&serde_json::json!(\{"name":"string","users":[\{\}],"workspaces":[\{\}]\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	Numeric ID of the organization.
group_id	integer	true	Numeric ID of the group.

Body

Name	Type	Description
name	string	Group name
users	Array of integer	Group users, optional
workspaces	Array of integer	Group workspaces

Response

200

Returns the created group data.

Name	Type	Description
at	string	-
group_id	integer	-
name	string	-
permissions	Array of string	-
users	Array of object	-
workspaces	Array of integer	-

users

Name	Type	Description
avatar_url	string	-
inactive	boolean	-
joined	boolean	-
name	string	-
user_id	integer	-

400

Possible error messages:

Invalid JSON input
Group name must be present
Group name too long, maximum length is 200
Name has already been taken
User {user} not exists in the organization {org}
Workspace {ws} not exists in the organization {org}

403

Forbidden

404

Invalid group ID.

DELETE Deletes group

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

Deletes a group from the specified organization

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

req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/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))

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

uri = URI('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_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/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));

import requests
from base64 import b64encode

data = requests.delete('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_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/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	Numeric ID of the organization.
group_id	integer	true	Numeric ID of the group.

Response

200

403

User does not have access to this resource

404

Invalid group ID.

PATCH Patch group

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

Patches a group in the specified organization. Patches are applied individually and each patch is validated separately.

This endpoint supports only the following operation combinations:

Adding users: op="add", path="/users"
Removing users: op="remove", path="/users"
Adding workspaces: op="add", path="/workspaces"
Removing workspaces: op="remove", path="/workspaces"

Limitations:

Maximum 100 patches per request
Maximum 100 values (user IDs or workspace IDs) per patch operation
Scalar fields (e.g., group name) cannot be modified via PATCH; use PUT endpoint instead

Request body schema: Array of patch objects, where each object contains:

op (string): Operation type, must be "add" or "remove"
path (string): Target path, must be "/users" or "/workspaces"
value (array of integers): Array of user IDs or workspace IDs

Example request: [ {"op": "add", "path": "/users", "value": [123, 456]}, {"op": "remove", "path": "/workspaces", "value": [789]} ]

curl -X PATCH https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id} \
  -H "Content-Type: application/json" \
  -d '[\{"op":"string","path":"string","value":[\{\}]\}]' \
  -u <email>:<password>

bytes, err := json.Marshal('[\{"op":"string","path":"string","value":[\{\}]\}]')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/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))

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

uri = URI('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
req.body = [\{"op":"string","path":"string","value":[\{\}]\}].to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id}", {
  method: "PATCH",
  body: [\{"op":"string","path":"string","value":[\{\}]\}],
  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.patch('https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id}', json=[\{"op":"string","path":"string","value":[\{\}]\}], 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::PATCH, "https://api.track.toggl.com/api/v9/organizations/{organization_id}/groups/{group_id}".to_string())
.json(&serde_json::json!([\{"op":"string","path":"string","value":[\{\}]\}]))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	Numeric ID of the organization.
group_id	integer	true	Numeric ID of the group.

Body

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
op	string	-
path	string	-
value	Array of integer	-

Response

200

Returns the result of the requested operations.

Name	Type	Description
failure	Array of object	-
success	Array of object	-

failure

Name	Type	Description
message	string	-
patch	object	-

patch

Name	Type	Description
op	string	-
path	string	-
value	Array of integer	-

success

Name	Type	Description
op	string	-
path	string	-
value	Array of integer	-

400

Possible error messages:

Invalid JSON input
Unsupported operation (invalid 'op' or 'path', or unsupported combination)
Value not present, or too many per patch operation (empty 'value' array or more than 100 values)
Too many operations (more than 100 patches in request)
Unknown group at organization
User {id} not exists in the organization {id}
Workspace {id} not exists in the organization {id}

403

User does not have permission to manage user groups.

404

Invalid group ID.

GET List of groups in a workspace within an organization with user assignments.

https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/groups

Returns list of groups in a workspace based on set of url parameters. List is sorted by name.

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

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/groups")
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/organizations/{organization_id}/workspaces/{workspace_id}/groups')
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/organizations/{organization_id}/workspaces/{workspace_id}/groups", {
  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/organizations/{organization_id}/workspaces/{workspace_id}/groups', 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/organizations/{organization_id}/workspaces/{workspace_id}/groups".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

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

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
at	string	-
group_id	integer	-
name	string	-
permissions	Array of string	-
users	Array of object	-
workspaces	Array of integer	-

users

Name	Type	Description
avatar_url	string	-
inactive	boolean	-
joined	boolean	-
name	string	-
user_id	integer	-

403

Forbidden

404

Resource can not be found

GET Get workspace project groups.

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

Get project groups for given workspace.

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

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/project_groups")
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}/project_groups')
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}/project_groups", {
  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}/project_groups', 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}/project_groups".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
project_ids	string	true	Project IDs separated by comma.

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
group_id	integer	-
id	integer	-
pid	integer	-
wid	integer	-

403

User does not have access to this resource.

500

Internal Server Error

POST Adds group to project.

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

Adds group to project for given workspace.

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

bytes, err := json.Marshal('\{"group_id":"integer","project_id":"integer"\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/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/api/v9/workspaces/{workspace_id}/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_id":"integer","project_id":"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}/project_groups", {
  method: "POST",
  body: \{"group_id":"integer","project_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/api/v9/workspaces/{workspace_id}/project_groups', json=\{"group_id":"integer","project_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/api/v9/workspaces/{workspace_id}/project_groups".to_string())
.json(&serde_json::json!(\{"group_id":"integer","project_id":"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
group_id	integer	Group ID
project_id	integer	Project ID

Response

200

Successful operation.

403

User does not have access to this resource.

500

Internal Server Error

DELETE Remove project group.

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

Remove project group for a given workspace.

curl -X DELETE https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/project_groups/{project_group_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}/project_groups/{project_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))

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

uri = URI('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/project_groups/{project_group_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}/project_groups/{project_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));

import requests
from base64 import b64encode

data = requests.delete('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/project_groups/{project_group_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}/project_groups/{project_group_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
project_group_id	integer	true	Numeric ID of the project group

Response

200

Successful operation.

403

User does not have access to this resource.

500

Internal Server Error

GET List of groups in organization with user and workspace assignments​

Parameters​

Path​

Query​

Response​

200​

items​

users​

400​

POST Create group​

Parameters​

Path​

Body​

Response​

200​

users​

400​

403​

PUT Edit group​

Parameters​

Path​

Body​

Response​

200​

users​

400​

403​

404​

DELETE Deletes group​

Parameters​

Path​

Response​

200​

403​

404​

PATCH Patch group​

Parameters​

Path​

Body​

items​

Response​

200​

failure​

patch​

success​

400​

403​

404​

GET List of groups in a workspace within an organization with user assignments.​

Parameters​

Path​

Response​

200​

items​

users​

403​

404​

GET Get workspace project groups.​

Parameters​

Path​

Query​

Response​

200​

items​

403​

500​

POST Adds group to project.​

Parameters​

Path​

Body​

Response​

200​

403​

500​

DELETE Remove project group.​

Parameters​

Path​

Response​

200​

403​

GET List of groups in organization with user and workspace assignments

Parameters

Path

Query

Response

200

items

users

400

POST Create group

Parameters

Path

Body

Response

200

users

400

403

PUT Edit group

Parameters

Path

Body

Response

200

users

400

403

404

DELETE Deletes group

Parameters

Path

Response

200

403

404

PATCH Patch group

Parameters

Path

Body

items

Response

200

failure

patch

success

400

403

404

GET List of groups in a workspace within an organization with user assignments.

Parameters

Path

Response

200

items

users

403

404

GET Get workspace project groups.

Parameters

Path

Query

Response

200

items

403

500

POST Adds group to project.

Parameters

Path

Body

Response

200

403

500

DELETE Remove project group.

Parameters

Path

Response

200

403