Me

GET Me

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

Returns details for the current user.

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

req, err := http.NewRequest(http.MethodGet, 
  "https://api.track.toggl.com/api/v9/me")
if err != nil {
    print(err)
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.SetBasicAuth("<email>", "<password>")

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

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

fmt.Print(string(body))

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

uri = URI('https://api.track.toggl.com/api/v9/me')
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/me", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

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

  Ok(())
}

Response

{
    "api_token": {
        "description": "will be omitted if empty",
        "type": "string"
    },
    "at": {
        "type": "string",
        "format": "date-time"
    },
    "beginning_of_week": {
        "type": "integer"
    },
    "country_id": {
        "type": "integer"
    },
    "created_at": {
        "type": "string",
        "format": "date-time"
    },
    "default_workspace_id": {
        "type": "integer"
    },
    "email": {
        "type": "string",
        "format": "email"
    },
    "fullname": {
        "type": "string"
    },
    "id": {
        "type": "integer"
    },
    "image_url": {
        "type": "string",
        "example": "http://example.com"
    },
    "intercom_hash": {
        "description": "will be omitted if empty",
        "type": "string"
    },
    "openid_email": {
        "type": "string",
        "format": "email"
    },
    "openid_enabled": {
        "type": "boolean"
    },
    "options": {
        "object": {
            "additionalProperties": "object"
        },
        "description": "will be omitted if empty"
    },
    "timezone": {
        "type": "string"
    },
    "updated_at": {
        "type": "string",
        "format": "date-time"
    }
}

User does not have access to this resource.

could not load user data

Internal Server Error

PUT Me

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

Updates details for the current user.

curl -X PUT https://api.track.toggl.com/api/v9/me \
  -H "Content-Type: application/json" \
  -d '{"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"string"}' \
  -u <email>:<password>

bytes, err := json.Marshal('{"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"string"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://api.track.toggl.com/api/v9/me", 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/me')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"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/me", {
  method: "PUT",
  body: {"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"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/me', json='{"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"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/me".to_string())
.json(&serde_json::json!({"beginning_of_week":"integer","country_id":"integer","current_password":"string","default_workspace_id":"integer","email":"string","fullname":"string","password":"string","timezone":"string"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Body

name	type	description
beginning_of_week	integer	-
country_id	integer	-
current_password	string	-
default_workspace_id	integer	-
email	string	-
fullname	string	-
password	string	-
timezone	string	-

Response

{
    "api_token": {
        "description": "will be omitted if empty",
        "type": "string"
    },
    "at": {
        "type": "string",
        "format": "date-time"
    },
    "beginning_of_week": {
        "type": "integer"
    },
    "country_id": {
        "type": "integer"
    },
    "created_at": {
        "type": "string",
        "format": "date-time"
    },
    "default_workspace_id": {
        "type": "integer"
    },
    "email": {
        "type": "string",
        "format": "email"
    },
    "fullname": {
        "type": "string"
    },
    "id": {
        "type": "integer"
    },
    "image_url": {
        "type": "string",
        "example": "http://example.com"
    },
    "openid_email": {
        "type": "string",
        "format": "email"
    },
    "openid_enabled": {
        "type": "boolean"
    },
    "options": {
        "object": {
            "additionalProperties": "object"
        },
        "description": "will be omitted if empty"
    },
    "timezone": {
        "type": "string"
    },
    "updated_at": {
        "type": "string",
        "format": "date-time"
    }
}

Possible error messages:

* Current password is not valid
* Current password must be present to change password
* Invalid beginning_of_week
* Invalid country_id
* Invalid default_workspace_id
* Invalid email
* Invalid fullname
* Invalid timezone
* Password should be at least 6 characters
* user with this email already exists

User does not have access to this resource.

GET Clients

https://api.track.toggl.com/api/v9/me/clients

Get Clients.

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

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")

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/me/clients')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/clients", {
  method: "GET",
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/clients', headers={'content-type': 'application/json'})
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();
  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(())
}

Response

[
    {
        "archived": {
            "type": "boolean"
        },
        "at": {
            "type": "string"
        },
        "foreign_id": {
            "description": "ForeignID - meta information for pipes, it should not be saved into DB!",
            "type": "string"
        },
        "id": {
            "type": "integer"
        },
        "name": {
            "type": "string"
        },
        "server_deleted_at": {
            "type": "string"
        },
        "wid": {
            "type": "integer"
        }
    }
]

Internal Server Error

POST CloseAccount

https://api.track.toggl.com/api/v9/me/close_account

Close Account

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

req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/me/close_account")
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/me/close_account')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/close_account", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

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

  Ok(())
}

Response

Successful operation.

Internal Server Error

GET Features

https://api.track.toggl.com/api/v9/me/features

Get features.

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

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

  Ok(())
}

Response

[
    {
        "features": {
            "items": [
                {
                    "enabled": {
                        "type": "boolean"
                    },
                    "feature_id": {
                        "type": "integer"
                    },
                    "name": {
                        "type": "string"
                    }
                }
            ]
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

Operation Forbidden

Internal Server Error

GET User's last known location

https://api.track.toggl.com/api/v9/me/location

Returns the client's IP-based location. If no data is present, empty response will be yielded.

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

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

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

uri = URI('https://api.track.toggl.com/api/v9/me/location')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/location", {
  method: "GET",
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/location', headers={'content-type': 'application/json'})
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();
  let json = client.request(Method::GET, "https://api.track.toggl.com/api/v9/me/location".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Response

{
    "city": {
        "type": "string"
    },
    "city_lat_long": {
        "type": "string"
    },
    "country_code": {
        "type": "string"
    },
    "country_name": {
        "type": "string"
    },
    "state": {
        "type": "string"
    }
}

Country with given ISO code not found

Internal Server Error

GET LostPassword

https://api.track.toggl.com/api/v9/me/lost_passwords

Verifies the user request to reset the password.

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

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

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

uri = URI('https://api.track.toggl.com/api/v9/me/lost_passwords')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/lost_passwords", {
  method: "GET",
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/lost_passwords', headers={'content-type': 'application/json'})
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();
  let json = client.request(Method::GET, "https://api.track.toggl.com/api/v9/me/lost_passwords".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Response

Successful operation

Internal Server Error

POST LostPassword

https://api.track.toggl.com/api/v9/me/lost_passwords/confirm

Handles lost password request confirmation.

curl -X POST https://api.track.toggl.com/api/v9/me/lost_passwords/confirm \
  -H "Content-Type: application/json" \
  -d '{"code":"string","password":"string","user_id":"integer"}'

bytes, err := json.Marshal('{"code":"string","password":"string","user_id":"integer"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/me/lost_passwords/confirm", bytes.NewBuffer(bytes))
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))

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

uri = URI('https://api.track.toggl.com/api/v9/me/lost_passwords/confirm')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"code":"string","password":"string","user_id":"integer"}.to_json
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/lost_passwords/confirm", {
  method: "POST",
  body: {"code":"string","password":"string","user_id":"integer"},
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/lost_passwords/confirm', json='{"code":"string","password":"string","user_id":"integer"}', headers={'content-type': 'application/json'})
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();
  let json = client.request(Method::POST, "https://api.track.toggl.com/api/v9/me/lost_passwords/confirm".to_string())
.json(&serde_json::json!({"code":"string","password":"string","user_id":"integer"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Body

name	type	description
code	string	-
password	string	-
user_id	integer	-

Response

Successful operation

Internal Server Error

POST LostPassword

https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code}

Handles the users request to reset the password.

curl -X POST https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code} \
  -H "Content-Type: application/json" \
  -d '{"email":"string"}'

bytes, err := json.Marshal('{"email":"string"}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code}", bytes.NewBuffer(bytes))
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))

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

uri = URI('https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = {"email":"string"}.to_json
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code}", {
  method: "POST",
  body: {"email":"string"},
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/lost_passwords/{token_code}', json='{"email":"string"}', headers={'content-type': 'application/json'})
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();
  let json = client.request(Method::POST, "https://api.track.toggl.com/api/v9/me/lost_passwords/{token_code}".to_string())
.json(&serde_json::json!({"email":"string"}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
token_code	string	true	Token Code

Body

name	type	description
email	string	-

Response

Successful operation

Internal Server Error

GET Organizations that a user is part of

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

Get all organizations a given user is part of.

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

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

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

uri = URI('https://api.track.toggl.com/api/v9/me/organizations')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://api.track.toggl.com/api/v9/me/organizations", {
  method: "GET",
  headers: {
    "Content-Type": "application/json"
  },
})
.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/me/organizations', headers={'content-type': 'application/json'})
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();
  let json = client.request(Method::GET, "https://api.track.toggl.com/api/v9/me/organizations".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

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"
        }
    }
]

Internal Server Error

GET Projects

https://api.track.toggl.com/api/v9/me/projects

Get projects

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

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

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

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

import requests
from base64 import b64encode

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

  Ok(())
}

Parameters

Query

name	type	required	description
include_archived	string	false	Include archived

Response

[
    {
        "active": {
            "type": "boolean"
        },
        "actual_hours": {
            "description": "End pro features",
            "type": "integer"
        },
        "at": {
            "type": "string"
        },
        "auto_estimates": {
            "type": "boolean"
        },
        "billable": {
            "description": "Pro features",
            "type": "boolean"
        },
        "cid": {
            "type": "integer"
        },
        "client_id": {
            "type": "integer"
        },
        "color": {
            "type": "string"
        },
        "created_at": {
            "type": "string"
        },
        "currency": {
            "type": "string"
        },
        "current_period": {
            "object": {
                "end_date": {
                    "type": "string"
                },
                "start_date": {
                    "type": "string"
                }
            }
        },
        "estimated_hours": {
            "type": "integer"
        },
        "first_time_entry": {
            "type": "string"
        },
        "fixed_fee": {
            "type": "number"
        },
        "foreign_id": {
            "description": "ForeignID - meta information for pipes, it should not be saved into DB!",
            "type": "string"
        },
        "id": {
            "type": "integer"
        },
        "is_private": {
            "type": "boolean"
        },
        "name": {
            "type": "string"
        },
        "rate": {
            "type": "number"
        },
        "rate_last_updated": {
            "type": "string"
        },
        "recurring": {
            "type": "boolean"
        },
        "recurring_parameters": {
            "items": [
                {
                    "custom_period": {
                        "type": "integer"
                    },
                    "estimated_seconds": {
                        "type": "integer"
                    },
                    "parameter_end_date": {
                        "type": "string"
                    },
                    "parameter_start_date": {
                        "type": "string"
                    },
                    "period": {
                        "type": "string"
                    },
                    "project_start_date": {
                        "type": "string"
                    }
                }
            ]
        },
        "server_deleted_at": {
            "type": "string"
        },
        "template": {
            "type": "boolean"
        },
        "wid": {
            "description": "Ideally we'd want object_id type things, but for usual reasons we need to keep both around, so, that's that",
            "type": "integer"
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

Invalid include_archived

Operation Forbidden

Internal Server Error

GET ProjectsPaginated

https://api.track.toggl.com/api/v9/me/projects/paginated

Get paginated projects.

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

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

  Ok(())
}

Parameters

Query

name	type	required	description
start_project_id	string	false	Start project id

Response

[
    {
        "active": {
            "type": "boolean"
        },
        "actual_hours": {
            "description": "End pro features",
            "type": "integer"
        },
        "at": {
            "type": "string"
        },
        "auto_estimates": {
            "type": "boolean"
        },
        "billable": {
            "description": "Pro features",
            "type": "boolean"
        },
        "cid": {
            "type": "integer"
        },
        "client_id": {
            "type": "integer"
        },
        "color": {
            "type": "string"
        },
        "created_at": {
            "type": "string"
        },
        "currency": {
            "type": "string"
        },
        "current_period": {
            "object": {
                "end_date": {
                    "type": "string"
                },
                "start_date": {
                    "type": "string"
                }
            }
        },
        "estimated_hours": {
            "type": "integer"
        },
        "first_time_entry": {
            "type": "string"
        },
        "fixed_fee": {
            "type": "number"
        },
        "foreign_id": {
            "description": "ForeignID - meta information for pipes, it should not be saved into DB!",
            "type": "string"
        },
        "id": {
            "type": "integer"
        },
        "is_private": {
            "type": "boolean"
        },
        "name": {
            "type": "string"
        },
        "rate": {
            "type": "number"
        },
        "rate_last_updated": {
            "type": "string"
        },
        "recurring": {
            "type": "boolean"
        },
        "recurring_parameters": {
            "items": [
                {
                    "custom_period": {
                        "type": "integer"
                    },
                    "estimated_seconds": {
                        "type": "integer"
                    },
                    "parameter_end_date": {
                        "type": "string"
                    },
                    "parameter_start_date": {
                        "type": "string"
                    },
                    "period": {
                        "type": "string"
                    },
                    "project_start_date": {
                        "type": "string"
                    }
                }
            ]
        },
        "server_deleted_at": {
            "type": "string"
        },
        "template": {
            "type": "boolean"
        },
        "wid": {
            "description": "Ideally we'd want object_id type things, but for usual reasons we need to keep both around, so, that's that",
            "type": "integer"
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

Operation Forbidden

Internal Server Error

GET Tags

https://api.track.toggl.com/api/v9/me/tags

Returns tags for the current user.

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

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

  Ok(())
}

Response

[
    {
        "at": {
            "type": "string"
        },
        "deleted_at": {
            "type": "string",
            "format": "date-time"
        },
        "id": {
            "type": "integer"
        },
        "name": {
            "type": "string"
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

User does not have access to this resource.

Internal Server Error

GET Tasks

https://api.track.toggl.com/api/v9/me/tasks

Returns tasks from projects in which the user is participating.

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

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

  Ok(())
}

Parameters

Query

name	type	required	description
since	string	false	since
include_not_active	string	false	Include tasks where active=false

Response

[
    {
        "active": {
            "type": "boolean"
        },
        "at": {
            "type": "string"
        },
        "estimated_seconds": {
            "type": "integer"
        },
        "id": {
            "type": "integer"
        },
        "name": {
            "type": "string"
        },
        "project_id": {
            "type": "integer"
        },
        "recurring": {
            "type": "boolean"
        },
        "server_deleted_at": {
            "type": "string"
        },
        "tracked_seconds": {
            "type": "integer"
        },
        "user_id": {
            "type": "integer"
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

Invalid include_not_active

User does not have access to this resource.

Internal Server Error

GET TrackReminders

https://api.track.toggl.com/api/v9/me/track_reminders

Returns a list of track reminders.

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

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

  Ok(())
}

Response

[
    {
        "created_at": {
            "type": "string"
        },
        "frequency": {
            "type": "integer"
        },
        "group_ids": {
            "type": [
                "integer"
            ]
        },
        "reminder_id": {
            "type": "integer"
        },
        "threshold": {
            "type": "integer"
        },
        "user_ids": {
            "type": [
                "integer"
            ]
        },
        "workspace_id": {
            "type": "integer"
        }
    }
]

User does not have access to this resource.

Internal Server Error

GET WebTimer

https://api.track.toggl.com/api/v9/me/web-timer

Get web timer.

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

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

  Ok(())
}

Response

Successful operation

Operation Forbidden

Resource can not be found

Internal Server Error

GET Me​

Response​

PUT Me​

Parameters​

Body​

Response​

GET Clients​

Response​

POST CloseAccount​

Response​

GET Features​

Response​

GET User's last known location​

Response​

GET LostPassword​

Response​

POST LostPassword​

Parameters​

Body​

Response​

POST LostPassword​

Parameters​

Path​

Body​

Response​

GET Organizations that a user is part of​

Response​

GET Projects​

Parameters​

Query​

Response​

GET ProjectsPaginated​

Parameters​

Query​

Response​

GET Tags​

Response​

GET Tasks​

Parameters​

Query​

Response​

GET TrackReminders​

Response​

GET WebTimer​

Response​

GET Me

Response

PUT Me

Parameters

Body

Response

GET Clients

Response

POST CloseAccount

Response

GET Features

Response

GET User's last known location

Response

GET LostPassword

Response

POST LostPassword

Parameters

Body

Response

POST LostPassword

Parameters

Path

Body

Response

GET Organizations that a user is part of

Response

GET Projects

Parameters

Query

Response

GET ProjectsPaginated

Parameters

Query

Response

GET Tags

Response

GET Tasks

Parameters

Query

Response

GET TrackReminders

Response

GET WebTimer

Response