Organizations

POST Creates a new organization

https://api.track.toggl.com/api/v9/organizations

Creates a new organization with a single workspace and assigns current user as the organization owner

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

bytes, err := json.Marshal('{"name":"string","workspace_name":"string"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/organizations", 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')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"name":"string","workspace_name":"string"}.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", {
  method: "POST",
  body: {"name":"string","workspace_name":"string"},
  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', json='{"name":"string","workspace_name":"string"}', 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".to_string())
.json(&serde_json::json!({"name":"string","workspace_name":"string"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Body

name	type	description
name	string	-
workspace_name	string	-

Response

{
    "id": {
        "type": "integer"
    },
    "name": {
        "type": "string"
    },
    "workspace_id": {
        "type": "integer"
    },
    "workspace_name": {
        "type": "string"
    }
}

Possible error messages:

* Invalid JSON input
* Field 'name' cannot be empty.
* organization name too long, maximum length is 140
* workspace name must contain non-space characters
* workspace name must be provided
* workspace name must not be longer than 140

GET Organization data

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

Returns organization name and current pricing plan

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

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

Response

{
    "admin": {
        "type": "boolean"
    },
    "at": {
        "type": "string",
        "format": "date-time"
    },
    "created_at": {
        "type": "string",
        "format": "date-time"
    },
    "id": {
        "type": "integer"
    },
    "is_chargify": {
        "type": "boolean"
    },
    "is_multi_workspace_enabled": {
        "description": "IsMultiWorkspaceEnabled returns true if organization option is_multi_workspace_enabled is set",
        "type": "boolean"
    },
    "is_unified": {
        "type": "boolean"
    },
    "max_workspaces": {
        "type": "integer"
    },
    "name": {
        "type": "string"
    },
    "owner": {
        "type": "boolean"
    },
    "payment_methods": {
        "type": "string"
    },
    "pricing_plan_id": {
        "type": "integer"
    },
    "server_deleted_at": {
        "type": "string",
        "format": "date-time"
    },
    "suspended_at": {
        "type": "string"
    },
    "trial_info": {
        "object": {
            "last_pricing_plan_id": {
                "type": "integer"
            },
            "next_payment_date": {
                "type": "string"
            },
            "trial": {
                "type": "boolean"
            },
            "trial_available": {
                "type": "boolean"
            },
            "trial_end_date": {
                "type": "string"
            }
        }
    },
    "user_count": {
        "type": "integer"
    }
}

PUT Updates an existing organization

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

Updates an existing organization

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

bytes, err := json.Marshal('{"name":"string"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_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}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"name":"string"}.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}", {
  method: "PUT",
  body: {"name":"string"},
  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}', json='{"name":"string"}', 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}".to_string())
.json(&serde_json::json!({"name":"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.

Body

name	type	description
name	string	-

Response

OK

Possible error messages:

* Invalid JSON input
* Invalid organization ID
* At least one field is required
* field 'name' cannot be empty
* organization name too long, maximum length is 140

GET List of users in organization

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

Returns list of users in organization based on set of url parameters: Result is paginated. Pagination params are returned in headers

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

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

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

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

import requests
from base64 import b64encode

data = requests.get('https://api.track.toggl.com/api/v9/organizations/{organization_id}/users', 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}/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	Numeric ID of the organization

Query

name	type	required	description
filter	string	false	Returns records where name or email contains this string
active_status	string	false	List of `active` `inactive` `invited` comma separated(if not present, all statuses)
only_admins	string	false	If true returns admins only
groups	string	false	Comma-separated list of groups ids, returns users belonging to these groups only
workspaces	string	false	Comma-separated list of workspaces ids, returns users belonging to this workspaces only
page	integer	false	Page number, default 1
per_page	integer	false	Number of items per page, default 50
sort_dir	string	false	Values 'asc' or 'desc', result is sorted on 'names' column, default 'asc'

Response

[
    {
        "admin": {
            "type": "boolean"
        },
        "avatar_url": {
            "type": "string"
        },
        "can_edit_email": {
            "type": "boolean"
        },
        "email": {
            "type": "string"
        },
        "groups": {
            "items": [
                {
                    "group_id": {
                        "type": "integer"
                    },
                    "name": {
                        "type": "string"
                    }
                }
            ]
        },
        "id": {
            "type": "integer"
        },
        "inactive": {
            "type": "boolean"
        },
        "invitation_code": {
            "type": "string"
        },
        "joined": {
            "type": "boolean"
        },
        "name": {
            "type": "string"
        },
        "owner": {
            "type": "boolean"
        },
        "user_id": {
            "type": "integer"
        },
        "workspaces": {
            "items": [
                {
                    "admin": {
                        "type": "boolean"
                    },
                    "name": {
                        "type": "string"
                    },
                    "workspace_id": {
                        "type": "integer"
                    }
                }
            ]
        }
    }
]

Possible error messages:

* Missing or invalid organization_id.
* active_status parameter can contain only 'active', 'inactive' or 'invited'.
* only_admins parameter can contain only 'true' or 'false'.
* Invalid value sent for 'page'.
* page parameter must contain values > 0.
* Invalid value sent for 'per_page'.
* per_page parameter must contain values > 0.
* sort_dir parameter can contain only 'asc' or 'desc'.
* Invalid value sent for 'groups'.
* Invalid value sent for 'workspaces'.

PATCH Apply changes in bulk to users in an organization

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

Apply changes in bulk to users in an organization (currently deletion only).

curl -X PATCH https://api.track.toggl.com/api/v9/organizations/{organization_id}/users \
  -H "Content-Type: application/json" \
  -d '{"delete":["integer"]}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"delete":["integer"]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_id}/users", bytes.NewBuffer(bytes))
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

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

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

fmt.Print(string(body))

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

uri = URI('https://api.track.toggl.com/api/v9/organizations/{organization_id}/users')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"delete":["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/organizations/{organization_id}/users", {
  method: "PATCH",
  body: {"delete":["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.patch('https://api.track.toggl.com/api/v9/organizations/{organization_id}/users', json='{"delete":["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::PATCH, "https://api.track.toggl.com/api/v9/organizations/{organization_id}/users".to_string())
.json(&serde_json::json!({"delete":["integer"]}))
  .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
delete	Array of integer	-

Response

OK

Possible error messages:

* Missing or invalid organization_id
* At least one organization user ID must be supplied.
* Organization user IDs must be unique.
* The following organization user IDs do not belong to this organization: '...'.
* Cannot remove the paying user with organization user ID='...'.
* Cannot remove the organization owner user with organization user ID='...'.

PUT Changes a single organization-user

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

Changes a single organization-user. Can affect the following values:

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

bytes, err := json.Marshal('{"email":"string","groups":["integer"],"inactive":"boolean","name":"string","organization_admin":"boolean","workspaces":[{"admin":"boolean","name":"string","workspace_id":"integer"}]}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_id}/users/{organization_user_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}/users/{organization_user_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"email":"string","groups":["integer"],"inactive":"boolean","name":"string","organization_admin":"boolean","workspaces":[{"admin":"boolean","name":"string","workspace_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/organizations/{organization_id}/users/{organization_user_id}", {
  method: "PUT",
  body: {"email":"string","groups":["integer"],"inactive":"boolean","name":"string","organization_admin":"boolean","workspaces":[{"admin":"boolean","name":"string","workspace_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.put('https://api.track.toggl.com/api/v9/organizations/{organization_id}/users/{organization_user_id}', json='{"email":"string","groups":["integer"],"inactive":"boolean","name":"string","organization_admin":"boolean","workspaces":[{"admin":"boolean","name":"string","workspace_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::PUT, "https://api.track.toggl.com/api/v9/organizations/{organization_id}/users/{organization_user_id}".to_string())
.json(&serde_json::json!({"email":"string","groups":["integer"],"inactive":"boolean","name":"string","organization_admin":"boolean","workspaces":[{"admin":"boolean","name":"string","workspace_id":"integer"}]}))
  .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

string

groups

Array of integer

inactive

boolean

name

string

organization_admin

boolean

workspaces

Array of

name	type	description
admin	boolean	-
name	string	-
workspace_id	integer	-

Response

OK

Possible error messages:

* Missing or invalid organization_id.
* User does not exist in the organization.
* At least one field is required.
* Field 'name' cannot be empty.
* Missing e-mail.
* Invalid e-mail: '...'
* Email already exists.
* Group '...' is not in Organization '...'.
* Workspace '...' is not in Organization '...'.
* Cannot remove admin privileges from owner.
* Cannot deactivate owner.
* Cannot remove admin privileges from paying user.
* Cannot deactivate paying user.
* User has multiple organizations.

Possible error messages:

* Invalid organization user ID.
* Failed to load user data.

GET Statistics for all workspaces in the organization

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

Returns map indexed by workspace ID where each map element contains workspace admins list, members count and groups count.

curl  https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/statistics \
  -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/statistics")
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/statistics')
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/statistics", {
  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/statistics', 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/statistics".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Response

Successful operation.

Forbidden

Resource can not be found

PUT Change assignments of users within a workspace.

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

Assign or remove users to/from a workspace or to/from groups belonging to said workspace.

curl -X PUT https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/assignments \
  -H "Content-Type: application/json" \
  -d '{"group_id":"integer","joined":"boolean","operation":"string","user_id":"integer"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"group_id":"integer","joined":"boolean","operation":"string","user_id":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/assignments", 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}/workspaces/{workspace_id}/assignments')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"group_id":"integer","joined":"boolean","operation":"string","user_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/organizations/{organization_id}/workspaces/{workspace_id}/assignments", {
  method: "PUT",
  body: {"group_id":"integer","joined":"boolean","operation":"string","user_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.put('https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/assignments', json='{"group_id":"integer","joined":"boolean","operation":"string","user_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::PUT, "https://api.track.toggl.com/api/v9/organizations/{organization_id}/workspaces/{workspace_id}/assignments".to_string())
.json(&serde_json::json!({"group_id":"integer","joined":"boolean","operation":"string","user_id":"integer"}))
  .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

Body

name	type	description
group_id	integer	-
joined	boolean	-
operation	string	-
user_id	integer	-

Response

OK

Possible error messages:

* Invalid JSON input
* Invalid organization ID.
* Nothing to change.
* Field operation can contain only 'add' or 'remove'.
* Cannot send user_id and group_id in the same element.
* One of user_id or group_id is required.
* Invalid user_id.
* Cannot remove workspace owner.
* Cannot remove paying user.
* Invalid group_id.
* Invalid workspace ID.

Forbidden

POST Creates a new organization​

Parameters​

Body​

Response​

GET Organization data​

Parameters​

Path​

Response​

PUT Updates an existing organization​

Parameters​

Path​

Body​

Response​

GET List of users in organization​

Parameters​

Path​

Query​

Response​

PATCH Apply changes in bulk to users in an organization​

Parameters​

Path​

Body​

Response​

PUT Changes a single organization-user​

Parameters​

Path​

Body​

Response​

GET Statistics for all workspaces in the organization​

Response​

PUT Change assignments of users within a workspace.​

Parameters​

Path​

Body​

Response​

POST Creates a new organization

Parameters

Body

Response

GET Organization data

Parameters

Path

Response

PUT Updates an existing organization

Parameters

Path

Body

Response

GET List of users in organization

Parameters

Path

Query

Response

PATCH Apply changes in bulk to users in an organization

Parameters

Path

Body

Response

PUT Changes a single organization-user

Parameters

Path

Body

Response

GET Statistics for all workspaces in the organization

Response

PUT Change assignments of users within a workspace.

Parameters

Path

Body

Response