Toggl API

https://engineering.toggl.com/docs
Admin
Toggl API provides comprehensive API documentation and access for Toggl Track (time tracking and...
Tokens:567,859
Snippets:2,196
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### GET Workspaces Implementation Examples

Source: https://engineering.toggl.com/docs/track/api/me

Examples for retrieving workspaces using different programming languages with Basic Authentication.

```bash
curl  https://api.track.toggl.com/api/v9/me/workspaces \  
  -H "Content-Type: application/json" \  
  -u <email>:<password>
```

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

--------------------------------

### Get Clients Request Examples

Source: https://engineering.toggl.com/docs/track/api/me/index.html

Examples of how to perform a GET request to the clients endpoint using various programming languages.

```bash
curl  https://api.track.toggl.com/api/v9/me/clients \
  -H "Content-Type: application/json" \
  -u <email>:<password>
```

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

```ruby
require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.track.toggl.com/api/v9/me/clients')
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://api.track.toggl.com/api/v9/me/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));
```

```python
import requests
from base64 import b64encode

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

  Ok(())
}
```

--------------------------------

### Setup Calendar Integration Examples

Source: https://engineering.toggl.com/docs/focus/api/calendar/index.html

Implementation examples for connecting a calendar integration across multiple languages using Basic Authentication.

```curl
curl  https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/integrations/calendar/setup \  
  -H "Content-Type: application/json" \  
  -u <email>:<password>  
```

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

--------------------------------

### Create a timesheet setup via API

Source: https://engineering.toggl.com/docs/track/api/approvals

Examples for creating a timesheet setup across various programming languages.

```bash
curl -X POST https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups \  
  -H "Content-Type: application/json" \  
  -d '{"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"string"}' \  
  -u <email>:<password>
```

```go
bytes, err := json.Marshal('{"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"string"}')  
if err != nil {  
    print(err)  
}  
req, err := http.NewRequest(http.MethodPost,   
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups", 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://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups')  
req = Net::HTTP::Post.new(uri)  
req['Content-Type'] = "application/json"  
req.body = {"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"string"}.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://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups", {  
  method: "POST",  
  body: {"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"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));
```

```python
import requests  
from base64 import b64encode  
  
data = requests.post('https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups', json={"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"string"}, 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://api.track.toggl.com/api/v9/workspaces/{workspace_id}/timesheet_setups".to_string())  
.json(&serde_json::json!({"approver_id":"integer","approver_ids":[{}],"approvers_layers":{},"email_reminder_enabled":"boolean","member_ids":[{}],"periodicity":"string","reminder_day":"integer","reminder_time":"string","slack_reminder_enabled":"boolean","start_date":"string"}))  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}
```

--------------------------------

### GET Setup Calendar Integration

Source: https://engineering.toggl.com/docs/focus/api/calendar/index.html

Endpoint URL for initiating the calendar integration setup.

```text
https://focus.toggl.com/api/workspaces/{workspace_id}/integrations/calendar/setup  
```

--------------------------------

### Retrieve timesheet setups across languages

Source: https://engineering.toggl.com/docs/track/api/approvals

Examples for fetching timesheet setups using various programming languages with Basic Authentication.

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

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

--------------------------------

### Retrieve timesheet setups across languages

Source: https://engineering.toggl.com/docs/track/api/approvals/index.html

Examples for fetching timesheet setups using various programming languages with Basic Authentication.

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

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

--------------------------------

### Get Single Workspace Request Examples

Source: https://engineering.toggl.com/docs/track/api/workspaces/index.html

Implementation examples for retrieving workspace data across multiple programming languages.

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

```go
req, err := http.NewRequest(http.MethodGet,   
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_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://api.track.toggl.com/api/v9/workspaces/{workspace_id}')  
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://api.track.toggl.com/api/v9/workspaces/{workspace_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));
```

```python
import requests  
from base64 import b64encode  
  
data = requests.get('https://api.track.toggl.com/api/v9/workspaces/{workspace_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::GET, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}".to_string())  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}
```

--------------------------------

### Get current subscription request examples

Source: https://engineering.toggl.com/docs/focus/api/subscriptions

Examples of how to perform a GET request to the subscription endpoint across various programming languages.

```bash
curl  https://focus.toggl.com/api/organizations/{organization_id}/subscriptions/current \  
  -H "Content-Type: application/json"  
```

```go
req, err := http.NewRequest(http.MethodGet,   
  "https://focus.toggl.com/api/organizations/{organization_id}/subscriptions/current")  
if err != nil {  
    print(err)  
}  
req.Header.Set("Content-Type", "application/json; charset=utf-8")  
  
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}/subscriptions/current')  
req = Net::HTTP::Get.new(uri)  
req['Content-Type'] = "application/json"  
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}/subscriptions/current", {  
  method: "GET",  
  headers: {  
	"Content-Type": "application/json"  
  },  
})  
.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}/subscriptions/current', headers={'content-type': 'application/json'})  
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();  
  let json = client.request(Method::GET, "https://focus.toggl.com/api/organizations/{organization_id}/subscriptions/current".to_string())  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}  
```

--------------------------------

### GET Logged Request Examples

Source: https://engineering.toggl.com/docs/track/api/me/index.html

Examples of how to perform a GET request to the /me/logged endpoint across various programming languages.

```bash
curl  https://api.track.toggl.com/api/v9/me/logged \  
  -H "Content-Type: application/json"  
```

```go
  
req, err := http.NewRequest(http.MethodGet,   
  "https://api.track.toggl.com/api/v9/me/logged")  
if err != nil {  
    print(err)  
}  
req.Header.Set("Content-Type", "application/json; charset=utf-8")  
  
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://api.track.toggl.com/api/v9/me/logged')  
req = Net::HTTP::Get.new(uri)  
req['Content-Type'] = "application/json"  
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://api.track.toggl.com/api/v9/me/logged", {  
  method: "GET",  
  headers: {  
	"Content-Type": "application/json"  
  },  
})  
.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://api.track.toggl.com/api/v9/me/logged', headers={'content-type': 'application/json'})  
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();  
  let json = client.request(Method::GET, "https://api.track.toggl.com/api/v9/me/logged".to_string())  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}  
```

--------------------------------

### List Projects Request Examples

Source: https://engineering.toggl.com/docs/focus/api/projects/index.html

Examples of how to perform a GET request to the projects endpoint using different programming languages and tools.

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

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

--------------------------------

### Get Client by ID Request Examples

Source: https://engineering.toggl.com/docs/focus/api/clients/index.html

Examples of how to retrieve a client by ID using various programming languages and tools.

```text
https://focus.toggl.com/api/workspaces/{workspace_id}/clients/{client_id}
```

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

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

```ruby
require 'net/http'
require 'uri'
require 'json'

uri = URI('https://focus.toggl.com/api/workspaces/{workspace_id}/clients/{client_id}')
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/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));
```

```python
import requests
from base64 import b64encode

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

  Ok(())
}
```

--------------------------------

### Get Workspace Project Implementation

Source: https://engineering.toggl.com/docs/track/api/projects

Examples for retrieving project data using various programming languages with Basic Authentication.

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

```go
req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}/projects/{project_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://api.track.toggl.com/api/v9/workspaces/{workspace_id}/projects/{project_id}')
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://api.track.toggl.com/api/v9/workspaces/{workspace_id}/projects/{project_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));
```

```python
import requests
from base64 import b64encode

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

  Ok(())
}
```

--------------------------------

### Get Single Workspace Request Examples

Source: https://engineering.toggl.com/docs/track/api/workspaces

Examples for fetching workspace data using various programming languages with Basic Authentication.

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

```go
  
req, err := http.NewRequest(http.MethodGet,   
  "https://api.track.toggl.com/api/v9/workspaces/{workspace_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://api.track.toggl.com/api/v9/workspaces/{workspace_id}')  
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://api.track.toggl.com/api/v9/workspaces/{workspace_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));
```

```python
import requests  
from base64 import b64encode  
  
data = requests.get('https://api.track.toggl.com/api/v9/workspaces/{workspace_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::GET, "https://api.track.toggl.com/api/v9/workspaces/{workspace_id}".to_string())  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}
```

--------------------------------

### Retrieve a timesheet setup by ID

Source: https://engineering.toggl.com/docs/focus/api/timesheet-setups

Examples for fetching a timesheet setup using various programming languages. Requires basic authentication with email and password.

```curl
curl  https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/timesheet-setups/{setup_id} \  
  -H "Content-Type: application/json" \  
  -u <email>:<password>  
```

```go
  
req, err := http.NewRequest(http.MethodGet,   
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/timesheet-setups/{setup_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}/workspaces/{workspace_id}/timesheet-setups/{setup_id}')  
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}/workspaces/{workspace_id}/timesheet-setups/{setup_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));  
```

```python
import requests  
from base64 import b64encode  
  
data = requests.get('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/timesheet-setups/{setup_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::GET, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/timesheet-setups/{setup_id}".to_string())  
  .header(CONTENT_TYPE, "application/json")  
  .send()  
  .await?  
  .json()  
  .await?;  
    
  println!("{:#?}", json);  
  
  Ok(())  
}  
```
Tokens:
Raw