Time-entries

GET List task time entries

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries

Returns a list of time-entries based on the provided workspace ID, task ID and filter params.

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

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

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID

Query

name	type	required	description
page	integer	false	page number
per_page	integer	false	results per page
order_by	[]string	false	order by
type	string	false	time entry type
archived	boolean	false	filter in/out archived TEs
time_block_id	integer	false	filter by timeblock id

Response

200

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

data

Name	Type	Description
archived_at	string	-
billable	boolean	-
billable_source	object	-
created_at	string	-
deleted_at	string	-
description	string	-
duration	integer	-
id	integer	-
project_id	integer	-
start	string	-
task_id	integer	null
time_block_id	integer	-
toggl_user_id	integer	-
type	object	-
updated_at	string	-
workspace_id	integer	-

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

POST Create a new time entry

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries

Creates a new time entry in the specified workspace. An optional user_id field can be provided to create a time entry on behalf of another user. When user_id differs from the authenticated user, the caller must have manage_time_entries permission.

curl -X POST https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries \
  -H "Content-Type: application/json" \
  -d '\{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"user_id":"integer"\}' \
  -u <email>:<password>

bytes, err := json.Marshal('\{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"user_id":"integer"\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries", 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = \{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"user_id":"integer"\}.to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries", {
  method: "POST",
  body: \{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"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.post('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries', json=\{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"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::POST, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries".to_string())
.json(&serde_json::json!(\{"billable":"boolean","description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\},"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	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID

Body

Name	Type	Description
billable	boolean	-
description	string	-
duration	integer	-
start	string	-
time_block_id	integer	-
type	object	-
user_id	integer	-

Response

201

Time entry created successfully

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

GET Get a time entry by ID

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}

Returns a time entry by the provided ID.

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

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

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	timeEntry ID

Response

200

Name	Type	Description
archived_at	string	-
billable	boolean	-
billable_source	object	-
created_at	string	-
deleted_at	string	-
description	string	-
duration	integer	-
id	integer	-
project_id	integer	-
start	string	-
task_id	integer	null
time_block_id	integer	-
toggl_user_id	integer	-
type	object	-
updated_at	string	-
workspace_id	integer	-

400

Invalid request

403

Insufficient permissions

404

TimeEntry does not exist

500

Internal Server Error

PUT Update time entry

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}

Update an existing time entry

curl -X PUT https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id} \
  -H "Content-Type: application/json" \
  -d '\{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\}'

bytes, err := json.Marshal('\{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPut, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}", 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Put.new(uri.path)
req['Content-Type'] = "application/json"
req.body = \{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\}.to_json
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}", {
  method: "PUT",
  body: \{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\},
  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.put('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}', json=\{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\}, 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::PUT, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}".to_string())
.json(&serde_json::json!(\{"description":"string","duration":"integer","start":"string","time_block_id":"integer","type":\{\}\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	TimeEntry ID

Body

Name	Type	Description
description	string	-
duration	integer	-
start	string	-
time_block_id	integer	-
type	object	-

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

DELETE Delete a time entry by ID

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}

Deletes a time entry by the provided ID.

curl -X DELETE https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id} \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodPut, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Delete.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}", {
  method: "DELETE",
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

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

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::DELETE, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	time entry ID

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

PATCH Partial update time entry

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}

Partial updates an existing time entry

curl -X PATCH https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id} \
  -H "Content-Type: application/json" \
  -d '\{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}'

bytes, err := json.Marshal('\{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}", 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
req.body = \{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}.to_json
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}", {
  method: "PATCH",
  body: \{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"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.patch('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}', json=\{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"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::PATCH, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}".to_string())
.json(&serde_json::json!(\{"billable":"boolean","description":"string","duration":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	TimeEntry ID

Body

Name	Type	Description
billable	boolean	-
description	string	null
duration	integer	-
reset_billable_to_default	boolean	-
start	string	null
task_id	integer	-
time_block_id	integer	-
type	string	-

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

POST Marks a TE as archived

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive

Marks the TE with the provided WS, task, and TE IDs as archived

curl -X POST https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive \
  -H "Content-Type: application/json"

req, err := http.NewRequest(http.MethodPost, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive")
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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive", {
  method: "POST",
  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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive', 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/archive".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	time entry ID

Response

204

No Content

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

PATCH Restore a time entry by ID

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore

Restores a time entry by the provided ID.

curl -X PATCH https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore")
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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore", {
  method: "PATCH",
  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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore', 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/restore".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	time entry ID

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

POST Unarchives a time entry

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive

Marks the TE with the provided WS, task, and TE IDs as unarchived

curl -X POST https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive \
  -H "Content-Type: application/json"

req, err := http.NewRequest(http.MethodPost, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive")
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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive", {
  method: "POST",
  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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive', 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/tasks/{task_id}/time-entries/{time_entry_id}/unarchive".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID
task_id	integer	true	task ID
time_entry_id	integer	true	time entry ID

Response

204

No Content

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

GET List task time entries

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries

Returns a list of time-entries based on the provided workspace ID and filter params.

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

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

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Query

name	type	required	description
date_from	string	true	from timestamp
date_to	string	true	from timestamp
task_id	integer	false	task id
status_id	integer	false	status id
type	string	false	time entry type
page	integer	false	page number
per_page	integer	false	results per page
order_by	[]string	false	order by
archived	boolean	false	filter in/out archived TEs
time_block_id	integer	false	filter by timeblock
include_taskless	boolean	false	include taskless time entries

Response

200

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

data

Name	Type	Description
archived_at	string	-
billable	boolean	-
billable_source	object	-
created_at	string	-
deleted_at	string	-
description	string	-
duration	integer	-
id	integer	-
project_id	integer	-
start	string	-
task	object	-
task_id	integer	null
time_block_id	integer	-
toggl_user_id	integer	-
type	object	-
updated_at	string	-
workspace_id	integer	-

task

Name	Type	Description
archived_at	string	-
assignee_user_ids	Array of integer	-
auto_log_time	boolean	-
billable	boolean	-
client	object	-
color	string	-
created_at	string	-
deleted_at	string	-
description	string	-
end_date	string	-
estimated_mins	integer	-
ghost_assignee_ids	Array of integer	-
id	integer	-
metadata	object	-
name	string	-
notes	string	-
parent_task_id	integer	-
parent_task_name	string	-
pinned	boolean	-
position	integer	-
priority	string	-
priority_at	string	-
private	boolean	-
project	object	-
project_id	integer	-
recurring_task_id	integer	-
reucrrence_date	object	-
rrule	string	-
source	string	-
start_date	string	-
status	object	-
status_id	integer	-
status_updated_at	string	-
tag_ids	Array of integer	-
tags	Array of object	-
toggl_user_id	integer	-
updated_at	string	-
workspace_id	integer	-

client

Name	Type	Description
id	integer	-
name	string	-

metadata

Name	Type	Description
all_day	boolean	-
calendar_event_id	integer	-
calendar_id	integer	-
external_id	string	-
ical_uid	string	-
meeting_link	string	-
project_assignment	object	-
updated_at	string	-

project_assignment

Name	Type	Description
accuracy	number	-
confirmed_at	string	-
match_tier	string	-
matched_name	string	-
normalized_name	string	-
origin	string	-
suggested_at	string	-

project

Name	Type	Description
archived_at	string	-
color	string	-
id	integer	-
name	string	-
permissions	Array of string	-
private	boolean	-
rate	object	-

rate

Name	Type	Description
billable	boolean	-
currency	string	-
end_at	string	-
has_more_rates	boolean	-
hourly_rate	number	-
project_color	string	-
project_created_at	string	-
project_id	integer	-
project_name	string	-
project_rate_id	integer	-
start_at	string	-
workspace_rate_id	integer	-

reucrrence_date

status

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

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

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

POST Create new time entries in bulk

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk

Creates new time entries in bulk for the specified workspace. An optional user_id field can be provided per entry to create time entries on behalf of another user. When user_id differs from the authenticated user, the caller must have manage_time_entries permission.

curl -X POST https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk \
  -H "Content-Type: application/json" \
  -d '[\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"user_id":"integer"\}]' \
  -u <email>:<password>

bytes, err := json.Marshal('[\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"user_id":"integer"\}]')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodPost, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk", 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path)
req['Content-Type'] = "application/json"
req.body = [\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"user_id":"integer"\}].to_json
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk", {
  method: "POST",
  body: [\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"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.post('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk', json=[\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"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::POST, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk".to_string())
.json(&serde_json::json!([\{"billable":"boolean","description":"string","duration":"integer","start":"string","task_id":"integer","time_block_id":"integer","type":\{\},"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	organization ID
workspace_id	integer	true	workspace ID

Body

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
billable	boolean	-
description	string	-
duration	integer	-
start	string	-
task_id	integer	-
time_block_id	integer	-
type	object	-
user_id	integer	-

Response

204

No Content

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

DELETE Delete time entries in bulk

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk

Deletes time entries by the provided IDs.

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

req, err := http.NewRequest(http.MethodPut, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk")
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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Delete.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk", {
  method: "DELETE",
  headers: {
	"Content-Type": "application/json",
	"Authorization": `Basic ${base64.encode(<email>:<password>)}`
  },
})
.then((resp) => resp.json())
.then((json) => {
  console.log(json);
})
.catch(err => console.error(err));

import requests
from base64 import b64encode

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

extern crate tokio;
extern crate serde_json;
use reqwest::{Client};
use reqwest::header::{CONTENT_TYPE};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
  let client = Client::new().basic_auth("<email>", "<password>");
  let json = client.request(Method::DELETE, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Query

name	type	required	description
ids	[]integer	true	TimeEntry IDs

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

PATCH Partial bulk update time entry

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk

Partial updates an existing time entry

curl -X PATCH https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk \
  -H "Content-Type: application/json" \
  -d '[\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}]'

bytes, err := json.Marshal('[\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}]')
if err != nil {
    print(err)
}
req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk", 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
req.body = [\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}].to_json
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk", {
  method: "PATCH",
  body: [\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"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.patch('https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk', json=[\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"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::PATCH, "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk".to_string())
.json(&serde_json::json!([\{"billable":"boolean","description":"string","duration":"integer","id":"integer","reset_billable_to_default":"boolean","start":"string","task_id":"integer","time_block_id":"integer","type":"string"\}]))
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Body

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
billable	boolean	-
description	string	null
duration	integer	-
id	integer	-
reset_billable_to_default	boolean	-
start	string	null
task_id	integer	-
time_block_id	integer	-
type	string	-

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

PATCH Restore time entries in bulk

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore

Restores time entries by the provided IDs.

curl -X PATCH https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore \
  -H "Content-Type: application/json" \
  -u <email>:<password>

req, err := http.NewRequest(http.MethodGet, 
  "https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore")
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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore')
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Patch.new(uri.path)
req['Content-Type'] = "application/json"
request.basic_auth '<email>', '<password>'
res = http.request(req)
puts JSON.parse(res.body)

fetch("https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore", {
  method: "PATCH",
  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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore', 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://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/bulk/restore".to_string())
  .header(CONTENT_TYPE, "application/json")
  .send()
  .await?
  .json()
  .await?;
  
  println!("{:#?}", json);

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Query

name	type	required	description
ids	[]integer	true	TimeEntry IDs

Response

204

No Content

400

Invalid request

403

Insufficient permissions

404

Time entry does not exist

500

Internal Server Error

GET List task time entries, streaming the response

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/stream

Returns a list of time-entries based on the provided workspace ID and filter params.

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

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

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Query

name	type	required	description
date_from	string	true	from timestamp
date_to	string	true	from timestamp
task_id	integer	false	task id
status_id	integer	false	status id
type	string	false	time entry type
order_by	[]string	false	order by
archived	boolean	false	filter in/out archived TEs
include_taskless	boolean	false	include taskless time entries

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
archived_at	string	-
billable	boolean	-
billable_source	object	-
created_at	string	-
deleted_at	string	-
description	string	-
duration	integer	-
id	integer	-
project_id	integer	-
start	string	-
task	object	-
task_id	integer	null
time_block_id	integer	-
toggl_user_id	integer	-
type	object	-
updated_at	string	-
workspace_id	integer	-

task

Name	Type	Description
archived_at	string	-
assignee_user_ids	Array of integer	-
auto_log_time	boolean	-
billable	boolean	-
client	object	-
color	string	-
created_at	string	-
deleted_at	string	-
description	string	-
end_date	string	-
estimated_mins	integer	-
ghost_assignee_ids	Array of integer	-
id	integer	-
metadata	object	-
name	string	-
notes	string	-
parent_task_id	integer	-
parent_task_name	string	-
pinned	boolean	-
position	integer	-
priority	string	-
priority_at	string	-
private	boolean	-
project	object	-
project_id	integer	-
recurring_task_id	integer	-
reucrrence_date	object	-
rrule	string	-
source	string	-
start_date	string	-
status	object	-
status_id	integer	-
status_updated_at	string	-
tag_ids	Array of integer	-
tags	Array of object	-
toggl_user_id	integer	-
updated_at	string	-
workspace_id	integer	-

client

Name	Type	Description
id	integer	-
name	string	-

metadata

Name	Type	Description
all_day	boolean	-
calendar_event_id	integer	-
calendar_id	integer	-
external_id	string	-
ical_uid	string	-
meeting_link	string	-
project_assignment	object	-
updated_at	string	-

project_assignment

Name	Type	Description
accuracy	number	-
confirmed_at	string	-
match_tier	string	-
matched_name	string	-
normalized_name	string	-
origin	string	-
suggested_at	string	-

project

Name	Type	Description
archived_at	string	-
color	string	-
id	integer	-
name	string	-
permissions	Array of string	-
private	boolean	-
rate	object	-

rate

Name	Type	Description
billable	boolean	-
currency	string	-
end_at	string	-
has_more_rates	boolean	-
hourly_rate	number	-
project_color	string	-
project_created_at	string	-
project_id	integer	-
project_name	string	-
project_rate_id	integer	-
start_at	string	-
workspace_rate_id	integer	-

reucrrence_date

status

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

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

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

GET List task time entries by time block ids, streaming the response

https://focus.toggl.com/api/organizations/{organization_id}/workspaces/{workspace_id}/time-entries/time-block-ids/stream

Returns a list of time-entries based on the provided workspace ID and filter params.

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

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

  Ok(())
}

Parameters

Path

name	type	required	description
organization_id	integer	true	organization ID
workspace_id	integer	true	workspace ID

Query

name	type	required	description
time_block_id	[]integer	true	filter by timeblock ids

Response

200

Name	Type	Description
items	Array of object	-

items

Name	Type	Description
archived_at	string	-
billable	boolean	-
billable_source	object	-
created_at	string	-
deleted_at	string	-
description	string	-
duration	integer	-
id	integer	-
project_id	integer	-
start	string	-
task_id	integer	null
time_block_id	integer	-
toggl_user_id	integer	-
type	object	-
updated_at	string	-
workspace_id	integer	-

400

Invalid request

403

Insufficient permissions

500

Internal Server Error

GET List task time entries​

Parameters​

Path​

Query​

Response​

200​

data​

400​

403​

500​

POST Create a new time entry​

Parameters​

Path​

Body​

Response​

201​

400​

403​

500​

GET Get a time entry by ID​

Parameters​

Path​

Response​

200​

400​

403​

404​

500​

PUT Update time entry​

Parameters​

Path​

Body​

Response​

204​

400​

403​

404​

500​

DELETE Delete a time entry by ID​

Parameters​

Path​

Response​

204​

400​

403​

404​

500​

PATCH Partial update time entry​

Parameters​

Path​

Body​

Response​

204​

400​

403​

404​

500​

POST Marks a TE as archived​

Parameters​

Path​

Response​

204​

400​

403​

500​

PATCH Restore a time entry by ID​

Parameters​

Path​

Response​

204​

400​

403​

404​

500​

POST Unarchives a time entry​

Parameters​

Path​

Response​

204​

400​

GET List task time entries

Parameters

Path

Query

Response

200

data

400

403

500

POST Create a new time entry

Parameters

Path

Body

Response

201

400

403

500

GET Get a time entry by ID

Parameters

Path

Response

200

400

403

404

500

PUT Update time entry

Parameters

Path

Body

Response

204

400

403

404

500

DELETE Delete a time entry by ID

Parameters

Path

Response

204

400

403

404

500

PATCH Partial update time entry

Parameters

Path

Body

Response

204

400

403

404

500

POST Marks a TE as archived

Parameters

Path

Response

204

400

403

500

PATCH Restore a time entry by ID

Parameters

Path

Response

204

400

403

404

500

POST Unarchives a time entry

Parameters

Path

Response

204

400