Menu

Mattering Automations Toggl Track integration

Connect Toggl Track to Mattering Automations: time entries, projects, clients, tasks, tags, workspaces, members and the Reports API as workflow steps, authorized with the API token from your Toggl profile page.

The Mattering Automations Toggl Track integration puts Toggl's time tracking on your automation canvas: list, read, create, update, stop and bulk edit time entries; create and maintain projects, clients, tags and tasks; manage workspaces, organizations, workspace members and project members; and run summary, detailed, weekly, project and per user reports. Fifty seven nodes in total, thirty that read and twenty seven that act, of which six delete something permanently.

The credential is a single API token. You copy it from the bottom of your own Toggl Track profile page, paste it into Add Connector once, and every node uses it. Toggl's own scheme sends that token as the HTTP Basic username with the fixed string api_token in the password position, and the connector supplies the constant so there is no second field to fill in and nothing to memorise.

Two properties of Toggl's API shape almost every design decision downstream, so they are worth reading before you build. The first is the hourly request quota, which starts at 30 requests per hour per user per organization on the Free plan and makes loop-per-record patterns unworkable there. The second is that Toggl's account and workspace responses contain a live api_token, which this integration strips out before a node returns anything. Both are covered in detail below.

Before you start

  • A Toggl Track account. The Free plan has API access and the token is already on your profile page, so there is no developer account to register, no application to create and no review process to wait on.
  • A decision about which Toggl user holds the connection. Every node acts as that user and inherits their role in each workspace and organization, and the hourly request quota is counted per user per organization, so the choice affects both what the nodes can see and how much they can do. For unattended automation, a user the team controls beats an individual's personal login, because a personal token leaves with the person.
  • An understanding of what the token is worth. It grants full access to every workspace and organization that user belongs to, and Toggl returns it inside some of its own responses, which is why this integration redacts it. Treat it exactly as you would a password.
  • Awareness of the request quota on your plan. Toggl allows 30 requests per hour per user per organization on Free, 240 on Starter, 600 on Premium, and custom quotas on Enterprise, for any request that names a workspace or organization. Requests about the token owner, such as the account and quota reads, sit on a separate allowance of 30 per hour that is the same on every plan.
  • A paid Toggl plan if you intend to use the task nodes or anything involving rates. Toggl lists tasks, which it calls sub projects, along with billable rates and project time estimates from the Starter plan, and labor costs, fixed fee projects and project templates from Premium. Toggl's API reference also states that the client archive endpoint is for premium workspaces only, which covers Toggl Track: Archive Client and Toggl Track: Restore Client.
  • Somewhere for the workflow to send its results. These nodes read and write Toggl; they do not deliver anything on their own, so pair them with a messaging, spreadsheet or Mattering Productivity node when the point is a report somebody reads.
  • A Mattering workspace with access to Automations, and permission to add a connector credential in it. The token is stored encrypted and shared at workspace level rather than held in an individual's local configuration.

Copy your Toggl Track API token

Toggl accepts three authentication methods and this integration deliberately supports only one of them. The API token is the right credential for an automation because it can be rotated without touching the account it belongs to. Toggl also accepts an email and password pair as HTTP Basic, and a session cookie; neither is supported here, because a stored integration credential should never be an account password.

Sign in to Toggl Track as the user who should hold the connection.
Open your profile page at track.toggl.com/profile and scroll to the bottom. The token is under API Token. Reveal and copy it.
This single token grants that user's full access to every workspace and organization they belong to. There are no scopes to narrow it and no read-only variant. Anyone who obtains it has whatever that Toggl user has, so store it nowhere else, and prefer a Toggl user the team controls over an individual's personal login for anything running unattended.
If you ever need to invalidate it, resetting the token on the same profile page is the way. Doing so breaks this connection until you paste the new value into the credential, so plan it rather than doing it mid run.

Connect Toggl Track to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Toggl Track from the list.
Click Create new credential and paste the token into the single API Token field, then save.
There is deliberately no second field here. Toggl's scheme puts the API token in the HTTP Basic username position and the fixed string api_token in the password position, and the connector holds that constant internally. A form asking you to type api_token into a password box would misrepresent what the secret is, since there is only one secret and the other half is a protocol constant.
Click Test Connection. Mattering calls Toggl's account endpoint, which takes no parameters and is the cheapest authenticated call available, so a successful response proves the token and the header wiring together.
A failed authentication in Toggl answers HTTP 403, not 401. Toggl's authentication page states this plainly. So a 403 at this step means the token is wrong, mistyped or reset, and is not the permissions problem the status code usually implies. A 403 later, on a node that names a workspace, genuinely can be an access problem.
All 57 Toggl Track nodes appear in your canvas palette, grouped as thirty reads and twenty seven actions.

Verify it works

Drop Toggl Track: Get My Account onto a canvas and run a test step. It is the natural probe: no parameters, and it answers the question that matters before any write, which is which Toggl user this connection acts as. Check the id, the email and the default workspace against the user you intended. Note that the api_token field in the response comes back with a redaction marker rather than a value, which is the integration doing its job rather than a failure.

Run Toggl Track: List My Workspaces next. This is the lister behind the workspace picker on nearly every other node, so a populated result here means the pickers elsewhere will work. It also shows each workspace's organization, plan flags and the token owner's role in it, which is the fastest way to see whether the workspace you are about to automate is on a plan that includes the features your workflow needs.

Finish with Toggl Track: Get API Quota, which reports how many requests remain in the current window and how many seconds until it resets. It is worth running once at the start so the number is concrete rather than abstract: on a Free organization the whole hourly allowance for workspace scoped calls is 30. Everything in this verify path is read-only and none of it can reach a delete node, so it is safe to re-run whenever you want to check the connection.

Node reference

57 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 30

Toggl Track: Get API Quota

toggl_track_get_api_quota

How many requests are left in the current sliding window, per organization, and how many seconds until it resets. Toggl answers HTTP 402 once the window is spent, and a Free organization only allows 30 requests per hour per user. Read this before a fan-out and branch on data[].remaining rather than discovering the limit halfway through a loop. The quota response headers are not visible to a canvas node; this body is. Reading it costs one request.

Toggl Track: Get Client

toggl_track_get_client

Get one client by id, with its notes, archived state and external reference.

Toggl Track: Get My Account

toggl_track_get_me

Get the account behind the API token: user id, name, email, timezone, default workspace and week start. Use it to resolve who the token acts as before writing anything. This is the connector's auth probe. The live response also contains the account's own api_token, so treat this node's output as secret. User-scoped, so it costs one of 30 requests per hour on every plan.

Toggl Track: Get Organization

toggl_track_get_organization

Get an organization's name, pricing plan, workspace allowance and user count. The pricing plan is the thing to read here: it determines the hourly request quota for every workspace underneath it, so a workflow can branch on it before deciding how much fan-out to attempt.

Toggl Track: Get Project

toggl_track_get_project

Get one project with its client, dates, colour, billable flag, rate, estimated hours and hours actually tracked.

Toggl Track: Get Project Statistics

toggl_track_get_project_statistics

Get the earliest and latest time entry on a project, which is the cheapest way to ask how long a project has actually been worked on. Toggl states this endpoint IGNORES running entries, so a timer started today will not move the latest value until it is stopped.

Toggl Track: Get Report Totals

toggl_track_detailed_report_totals

The totals behind a detailed report, without the rows: seconds tracked, billable amount, labour cost, how many days had any tracking, and the rates that made up the money. Optionally returns a bucketed graph at day, week or month granularity. This is the cheapest node in the connector for answering how much time or money a window contains, because it is one request no matter how many entries are in it.

Toggl Track: Get Running Time Entry

toggl_track_get_current_time_entry

Get the timer that is running right now for the token owner, or null if nothing is running. The entry's duration is negative while it runs; its start time is the useful field. Pair with Toggl Track: Stop Time Entry to close whatever is open.

Toggl Track: Get Task

toggl_track_get_task

Get one task with its estimate in seconds, the seconds actually tracked against it, whether it is still open, and which project and client it belongs to.

Toggl Track: Get Time Entry

toggl_track_get_time_entry

Get one of the token owner's time entries by id. Scoped to the account behind the token: another user's entry is not readable here even for an admin, which is what the Reports API is for.

Toggl Track: Get Workspace

toggl_track_get_workspace

Get one workspace's settings: name, organization, plan flags, default currency and hourly rate, rounding rules and who may create projects or tags. Read this before writing rates or billable flags, since those are paid-plan features and are silently ignored on a Free workspace. The live response carries the workspace's legacy api_token, so treat this node's output as secret.

Toggl Track: Get Workspace Statistics

toggl_track_get_workspace_statistics

Get a workspace's admin list, member count and group count in one request. A cheap headcount check that does not spend a request per member the way listing them does.

Toggl Track: List Clients

toggl_track_list_clients

List a workspace's clients, optionally filtered to active or archived ones or by a name fragment. Clients are what projects hang off, so this is usually the first read in a billing workflow.

Toggl Track: List My Organizations

toggl_track_list_my_organizations

List every organization the token's user belongs to, with the pricing plan name, workspace allowance and user count. The plan matters beyond billing: it sets the hourly request quota for every workspace under it, and gates billable rates, labor costs and saved reports.

Toggl Track: List My Projects

toggl_track_list_my_projects

List every project the token owner can see, ACROSS all their workspaces, in one request. Useful when a workflow does not know which workspace a project lives in. This is user-scoped, so it draws on the flat 30 per hour user quota rather than a workspace's.

Toggl Track: List My Workspaces

toggl_track_list_my_workspaces

List every workspace the token can reach, with each workspace's organization, plan flags, default currency and the token owner's role in it. This is the lister behind the workspace picker on every other node. The live response also carries each workspace's legacy api_token, so treat this node's output as secret.

Toggl Track: List Organization Users

toggl_track_list_organization_users

List everyone in an organization, across its workspaces, including people who are only INVITED and have not joined yet. This is the wider directory: use Toggl Track: List Workspace Users when the question is who can track time in one workspace.

Toggl Track: List Project Members

toggl_track_list_project_users

List who is assigned to which projects in a workspace, with each assignment's manager flag, rate and labor cost. Rows carry ids only, no names: join them against Toggl Track: List Workspace Users on user_id if a human-readable answer is needed.

Toggl Track: List Project Tasks

toggl_track_list_project_tasks

List one project's tasks as a plain array, with each task's estimate, tracked seconds and assignee. This is the lister behind the task picker, chosen over the workspace-wide one because it is already scoped to the chosen project and its rows are a flat array.

Toggl Track: List Tags

toggl_track_list_tags

List a workspace's tags. This is the lister behind the tag picker, and the way to turn tag names into the tag IDs that the reporting nodes filter on.

Toggl Track: List Time Entries

toggl_track_list_time_entries

List the token owner's own time entries, optionally within a date window. This is the only entry lister outside the Reports API and it covers ONE user: use Toggl Track: Run Detailed Report for a whole team. A running entry comes back with a null stop and a NEGATIVE duration (minus the start time in UNIX seconds), which is a marker, not a length, so never add it to real durations.

Toggl Track: List Workspace Members

toggl_track_list_workspace_members

List the MEMBERSHIP rows for a workspace: role, billable rate, labor cost, group memberships, timezone and working hours, plus each row's invite state. Each row's id is the workspace-user id used when updating or removing a member, which is NOT the same number as the user id in the same row.

Toggl Track: List Workspace Projects

toggl_track_list_workspace_projects

List a workspace's projects with their client, colour, billable flag, rate, estimated and actual hours. This is the lister behind the project picker on every project-scoped node. All filters are optional despite what Toggl's Swagger marks as required.

Toggl Track: List Workspace Tasks

toggl_track_list_workspace_tasks

List every task in a workspace, across projects, with paging. This is the ONE lister in this connector that does not return a bare array: its rows live under data.data[], alongside page, per_page and total_count. Tasks are a paid-plan feature in Toggl Track.

Toggl Track: List Workspace Users

toggl_track_list_workspace_users

List a workspace's users as flat rows of id, full name, email, role and active state. This is the lister behind every user picker in this connector. For the membership record itself, with rates, labor costs and group assignments, use Toggl Track: List Workspace Members.

Toggl Track: Run Detailed Report

toggl_track_detailed_report

Every time entry in a window, for the WHOLE workspace rather than one user, with project, client, task, tags, user and billable amount on each row. This is the node to reach for when building an invoice or exporting a timesheet. Each row carries a nested time_entries array holding the individual entries and their start, stop and seconds. Paging is driven by response HEADERS that a canvas node cannot see, so raise the page size to cover the window in one call and treat a result AT the page size as truncated.

Toggl Track: Run Project Summary Report

toggl_track_project_report

One project's totals for a window: seconds tracked, billable amount, labour cost, how many days saw any tracking, the rates involved, and a bucketed graph. Use it for a project health check without pulling every entry. Toggl returns 402 if the workspace's plan does not include the feature and 403 if the project is not accessible.

Toggl Track: Run Project Users Summary Report

toggl_track_project_summary_report

Tracked and billable seconds per project per user for a window, as flat rows of project_id, user_id, tracked_seconds and billable_seconds. The cheapest way to answer who worked on what: one request for the whole workspace. Rows carry ids only, so join them against Toggl Track: List Workspace Projects and List Workspace Users for names.

Toggl Track: Run Summary Report

toggl_track_summary_report

Total tracked time for a date window, grouped and sub-grouped the way the Toggl web report does it: by project, client, user, task or tag. One request answers a question that would otherwise take one call per entity, which is the difference between fitting inside a 30 per hour quota and not. The report covers ONE workspace; the Reports API does not do cross-workspace reports.

Toggl Track: Run Weekly Report

toggl_track_weekly_report

A seven-day grid of tracked time or billable amounts, grouped by user and project. Each row's seconds and billable_seconds are ARRAYS of one value per day of the week, in order, with no dates attached, so index 0 means the first day of the requested week. Good for a standing weekly status message; use the detailed report when individual entries are needed.

Action nodes 27

Toggl Track: Add Project Member

toggl_track_add_project_user

Assign a user to a project, optionally as its manager and with a per-project rate and labor cost. On a private project this is what makes the project visible to that person at all. Toggl's authorization layer is eventually consistent, so allow two to five seconds after creating a project before assigning people to it.

Toggl Track: Archive Client

toggl_track_archive_client

Archive a client AND its projects, hiding them from pickers while keeping every time entry intact. This is the safe alternative to deleting a client, and it is reversible with Toggl Track: Restore Client. Toggl documents archiving as a premium-workspace feature, so a Free workspace will refuse it.

Toggl Track: Bulk Edit Time Entries

toggl_track_bulk_edit_time_entries

Apply the same JSON Patch operations to up to 100 time entries in ONE request, which matters a lot at 30 requests per hour: retagging fifty entries is one call, not fifty. Toggl executes this PARTIALLY on error, with no transaction and no rollback, so the response's success and failure arrays are the record of what actually happened.

Toggl Track: Bulk Update Projects

toggl_track_bulk_update_projects

Apply the same JSON Patch operations to several projects in ONE request, which is how to archive or recolour a batch without spending a request each at 30 per hour. Like the bulk time-entry edit, this can apply partially, so read the success and failure arrays.

Toggl Track: Create Client

toggl_track_create_client

Create a client in a workspace. Toggl does not deduplicate by name, so running this twice produces two clients with the same name; check with Toggl Track: List Clients first if the workflow can retry.

Toggl Track: Create Project

toggl_track_create_project

Create a project in a workspace, optionally under a client and from a template. Billable, rate, currency, fixed fee and estimates are paid-plan features. Toggl's authorization layer is eventually consistent, so wait a couple of seconds before assigning users to a project you just created.

Toggl Track: Create Tag

toggl_track_create_tag

Create a workspace tag. Usually unnecessary: creating or updating a time entry with tag NAMES creates any missing tags automatically. Use this when the tag must exist before any time is tracked, or when the workspace restricts tag creation to admins.

Toggl Track: Create Task

toggl_track_create_task

Create a task inside a project. Tasks are a paid-plan feature in Toggl Track, so this fails on a Free workspace. The estimate is in SECONDS, not hours.

Toggl Track: Create Time Entry

toggl_track_create_time_entry

Log time, either finished or still running. For a finished entry send a start and either a stop or a positive duration in seconds; the two must agree if you send both. To START a running timer, send the start time and a duration of -1. Tags named here that do not exist yet are created automatically. Reversible only in the sense that the entry can be deleted again.

Toggl Track: Create Workspace

toggl_track_create_workspace

Create a workspace inside an existing organization. The organization's plan decides how many workspaces are allowed (a Free organization allows one). Toggl's authorization layer is eventually consistent: the vendor recommends waiting two to five seconds before using a newly created workspace, so put a delay before the next node rather than chaining straight into it.

Toggl Track: Delete Client

toggl_track_delete_client

DESTRUCTIVE AND IRREVERSIBLE: permanently deletes a client. The client's projects lose their client association, and every report grouped or filtered by that client stops resolving it. There is no undo. Use Toggl Track: Archive Client instead unless the record genuinely has to disappear.

Toggl Track: Delete Project

toggl_track_delete_project

DESTRUCTIVE AND IRREVERSIBLE: permanently deletes a project. Its blast radius is larger than the project row, because the time entries deletion mode decides what happens to every hour ever tracked against it: unassign detaches them and keeps them, delete DESTROYS THEM. This node defaults to unassign for that reason. There is no undo either way. To retire a project reversibly, update it with active set to false instead.

Toggl Track: Delete Tag

toggl_track_delete_tag

DESTRUCTIVE AND IRREVERSIBLE: permanently deletes a tag and strips it from every time entry that carried it. The entries survive, but the classification is gone from all of them at once and recreating a tag with the same name does not reattach it. Reports filtered by that tag will return nothing afterwards. Rename the tag instead if the goal is tidying.

Toggl Track: Delete Task

toggl_track_delete_task

DESTRUCTIVE AND IRREVERSIBLE: permanently deletes a task. Time entries tracked against it lose their task association and any report broken down by task stops resolving it, so the shape of past reporting changes. There is no undo. To close a task out without losing that structure, update it with active set to false instead.

Toggl Track: Delete Time Entry

toggl_track_delete_time_entry

DESTRUCTIVE AND IRREVERSIBLE: permanently deletes a time entry. Toggl has no trash and no undo for time entries, so the recorded work is gone along with its description, tags and billable amount, and any report already run stops matching. Read the entry first if you might need to recreate it. To detach an entry from a project without losing it, update it with a blank project instead.

Toggl Track: Invite Users To Organization

toggl_track_invite_users

Invite one or more people to an organization by email, optionally placing them into named workspaces, user groups and a project in the same call. Adding a seat can change what the organization is billed, so treat this as a spending action. The response returns an invite URL per person, which is what to send if email delivery is skipped.

Toggl Track: Remove Project Member

toggl_track_remove_project_user

Remove someone's assignment to a project. Their time entries on that project are NOT touched; only the assignment goes, and adding them back restores access. On a private project this removes their visibility of it. Note this takes the ASSIGNMENT id, not the user id.

Toggl Track: Remove Workspace Member

toggl_track_remove_workspace_member

DESTRUCTIVE: removes a person from the workspace. Their membership record goes with its role, rate, labor cost and group assignments, and they lose access immediately. Restoring it means a fresh invitation and reconfiguring everything by hand. Deactivate them instead with Toggl Track: Update Workspace Member if the goal is to stop them tracking time.

Toggl Track: Rename Tag

toggl_track_update_tag

Rename a tag. The tag keeps its id, so every time entry carrying it follows the new name; any saved filter written against the OLD NAME rather than the id will stop matching.

Toggl Track: Restore Client

toggl_track_restore_client

Un-archive a client, and either all of its projects or a named subset. The inverse of Toggl Track: Archive Client.

Toggl Track: Stop Time Entry

toggl_track_stop_time_entry

Stop a running timer, which fills in its stop time and turns its negative placeholder duration into a real length in seconds. Get the id from Toggl Track: Get Running Time Entry. Stopping an entry that is already stopped is an error, not a no-op.

Toggl Track: Update Client

toggl_track_update_client

Rename a client or change its notes and external reference. Archiving is a separate call: use Toggl Track: Archive Client rather than trying to set a flag here.

Toggl Track: Update Project

toggl_track_update_project

Change a project in place. Setting active to false ARCHIVES the project, which is the reversible way to retire one; deleting is not. When changing the rate, the rate change mode decides whether already-tracked time is repriced, so override-all can silently rewrite historical invoicing amounts.

Toggl Track: Update Task

toggl_track_update_task

Change a task: rename it, re-estimate it, reassign it, or mark it done by setting active to false. Marking a task done keeps every time entry attached to it, so this is the safe way to close work out.

Toggl Track: Update Time Entry

toggl_track_update_time_entry

Change an existing time entry: its description, times, project, task, billability or tags. Toggl's own guidance is to send only the fields that changed. Tag edits are controlled by the tag action field, which decides whether the tags you send are added to or removed from the entry.

Toggl Track: Update Workspace

toggl_track_update_workspace

Change a workspace's settings. Send only the fields you are changing, per Toggl's own guidance. Do not send paid-plan fields (default currency, default hourly rate, rounding, rate change mode) on a Free workspace: the vendor asks clients not to, and the request can be rejected rather than ignored.

Toggl Track: Update Workspace Member

toggl_track_update_workspace_member

Change a member's role, rate, labor cost, working hours or billing visibility. Setting inactive to true DEACTIVATES the member, which is the reversible alternative to removing them: their history stays and they can be reactivated. Rates and labor costs are paid-plan features.

Using the integration

One host, two APIs, and which one a node sits on

Toggl Track is two APIs sharing a hostname, and knowing which one a node uses explains most of its behaviour. The v9 API is conventional REST: filters go in the query string, and every workspace, organization, project, client, tag, task, member and time entry node lives there. The Reports API v3 is POST only even for its reads, takes its filters including the date window in a JSON body, and is scoped to exactly one workspace per request, since every one of its paths names a single workspace. The five report nodes and Toggl Track: Get Report Totals sit there. You do not have to assemble either shape yourself; the difference shows up as which fields a node offers and what its output looks like. It also explains why a multi workspace summary means one report node per workspace with the results combined afterwards, rather than one call with a list of workspaces.

Design around the request quota, because it is the binding constraint

Toggl runs two independent limiting mechanisms. The first is a sliding window request quota on any call that names a workspace or an organization: 30 per hour per user per organization on Free, 240 on Starter, 600 on Premium, custom on Enterprise. Exceeding it returns HTTP 402, and it does not clear until the window moves. The second is a leaky bucket per token and IP address, which returns HTTP 429; Toggl suggests one request per second as a safe pace and asks clients to back off for a few minutes on a 429. Thirty per hour is roughly one request every two minutes, so a workflow that makes one call per project or per person is not viable on a Free organization. Build the other way around: use the reporting nodes, which answer a whole workspace question in a single request, and the bulk nodes, which change many records in one. Toggl Track: Get API Quota exists so a workflow can read what is left and branch on it instead of hitting the ceiling mid run. One useful detail: requests about the token owner, such as the account read, draw on a separate 30 per hour allowance that is flat across every plan, so identity reads do not eat the workspace budget.

The api_token in Toggl's own responses, and what this integration does about it

Toggl's account response, its workspace list and its single workspace read each return a live api_token field: the caller's own token, and each workspace's legacy one. That value is the credential itself, so it deserves more than a warning in a description. This integration strips it recursively out of the output of Toggl Track: Get My Account, Toggl Track: List My Workspaces and Toggl Track: Get Workspace, replacing it with a redaction marker before the node returns anything. The reason is that node output does not stay in the node: it lands in run logs, gets written to spreadsheets, gets posted into chat, and gets handed to AI steps, and an assistant driving these tools over MCP forwards whatever it receives. The surrounding data in those three responses is the entire point of the nodes, so the nodes ship and the secret is removed rather than the other way around. Worth carrying away beyond Mattering: if you call those same Toggl endpoints from anywhere else and pipe the raw response onward, you are moving your own token with it.

Which nodes need a paid Toggl plan

Several of these nodes touch features Toggl gates by plan, and the failure looks like a quota error rather than a plan error, so it is worth knowing in advance. Toggl lists tasks, which it describes as sub projects, from the Starter plan, so all six task nodes need Starter or above. Billable rates and project time estimates also start at Starter, which affects billable amounts in reports and the estimate fields on projects and tasks. Labor costs, fixed fee projects and project templates start at Premium, which affects the labor cost fields on the member and project nodes, the fixed fee field and template option on Toggl Track: Create Project, and the labor cost figures in Toggl Track: Get Report Totals. Toggl's API reference states that the client archive endpoint is for premium workspaces only, which covers Toggl Track: Archive Client and Toggl Track: Restore Client. Toggl also asks clients not to send fields their plan does not include, such as a default currency, an hourly rate or a rounding rule, and warns that such a request can be rejected outright rather than ignored, so a create node with a rate filled in can fail where the same node without it succeeds.

The two bulk nodes, and reading their response properly

Toggl Track: Bulk Edit Time Entries applies the same JSON Patch operations to up to 100 time entries in one request, which Toggl documents as the per request limit, and Toggl Track: Bulk Update Projects does the same for projects. At 30 requests per hour these are not a convenience, they are the difference between a workflow being possible and not: retagging fifty entries is one call rather than fifty. The thing to get right is how you read the result. Toggl states plainly that the patch executes partially when some records fail, with no transaction and no rollback, so a run in which half the entries failed still answers HTTP 200. Branch on the success and failure arrays in the response body rather than on the status code, and log the failure array, because it carries the id and the reason per record and is the only record of what actually happened.

Running timers, negative durations, and stopping them safely

A running entry in Toggl stores its duration as the negative of its start time in UNIX seconds. It is a marker meaning still running, not a length, and any workflow that sums durations across a window containing one running timer produces a number nine digits wrong. Toggl Track: List Time Entries says so on the node and declares no additive measure on that field for the same reason. The safe pattern is to read Toggl Track: Get Running Time Entry, which returns whatever is open for the token owner or nothing at all, branch on whether anything came back, and only then call Toggl Track: Stop Time Entry, because stopping an already stopped entry is an error rather than a no operation. Take totals from the reporting nodes, which count real durations. One related quirk: Toggl Track: Get Project Statistics ignores running entries entirely, so a timer started today will not move a project's latest entry date until it is stopped.

Users, members, and the two ids that are not the same number

This connector has two people listers and they answer different questions. Toggl Track: List Workspace Users returns flat rows of id, full name, email, role and active state, and is the lister behind every user picker here. Toggl Track: List Workspace Members returns the membership record instead, with role, billable rate, labor cost, group memberships, timezone, working hours and invite state. The trap is that a membership row's own id and the user id inside that same row are different numbers, and it is the membership id that Toggl Track: Update Workspace Member and Toggl Track: Remove Workspace Member take. Passing the wrong one either 404s or, worse, reaches a different membership. The two pickers are fed from different listers precisely so the right number is offered on the right field. Toggl Track: List Project Members is a third shape again: it carries ids only with no names at all, so join it against the workspace user list on user_id when a human needs to read the result.

Reading reports, and the paging limit you should know about

Toggl Track: Run Summary Report totals a window for a workspace grouped the way the Toggl web report does, Toggl Track: Run Detailed Report returns the individual entries with project, client, task, tags, user and billable amount per row, Toggl Track: Run Weekly Report gives a seven day grid, and Toggl Track: Run Project Users Summary Report gives flat tracked and billable seconds per project per user. Two shape details matter when you consume them. Weekly report rows carry arrays of one value per day with no dates attached, so index zero means the first day of the requested window rather than a named weekday. And the detailed report pages through response headers that a canvas node cannot read, so a second page cannot be requested from a previous node's output. The mitigation is built into the node: raise the page size so one call covers the window, and treat a result sitting exactly at the page size as truncated rather than complete. This is the single most likely cause of a report that looks right and is quietly short.

Creating things, then waiting before you use them

Toggl states that its authorization layer is eventually consistent and recommends waiting two to five seconds, retrying up to three times, before using a newly created organization, workspace, project or group. That is not a theoretical caveat: chaining Toggl Track: Create Project straight into Toggl Track: Add Project Member produces intermittent 403s that look exactly like a permissions bug and disappear when you run the same workflow again. Put a short delay between the create and the first use, and prefer a retry over treating the first failure as final. Toggl Track: Create Workspace carries the same caution. A separate detail on creates: Toggl does not deduplicate clients by name, so Toggl Track: Create Client run twice produces two clients with the same name, which makes a check against Toggl Track: List Clients worthwhile in any workflow that might retry.

The six destructive nodes and their reversible alternatives

Toggl has no trash and no restore endpoint for anything these nodes delete, so treat all six as permanent and put them behind a condition or an approval rather than in an assistant's open hands. Toggl Track: Delete Time Entry destroys the recorded work with its description, tags and billable amount. Toggl Track: Delete Tag strips the tag from every entry that carried it at once, and recreating the name does not reattach it. Toggl Track: Delete Task and Toggl Track: Delete Client leave the time entries but break the association, so reports grouped by them stop resolving. Toggl Track: Remove Workspace Member takes the role, rate, labor cost and group assignments with it, and restoring means a fresh invitation and manual reconfiguration. Toggl Track: Delete Project has the largest blast radius, because its time entries deletion mode decides what happens to every hour ever tracked against the project: one value detaches them and keeps them, the other destroys them, and the node defaults to detaching. Each of these has a reversible alternative that is usually what was actually wanted: archive the client, mark the project or task inactive, rename the tag, deactivate the member with Toggl Track: Update Workspace Member, or clear an entry's project instead of deleting the entry.

Troubleshooting

Test Connection fails with a 403
In Toggl a 403 at this step is an authentication failure, not a permissions problem. Toggl's authentication page states that when authentication fails it returns HTTP 403, which is unusual enough to send people looking for a missing permission that does not exist. Check the token itself first: that it was copied whole from the bottom of the profile page, that no whitespace came with it, and that it has not been reset since. Re-copy it from track.toggl.com/profile and paste it into the credential again. A 403 from a node that names a specific workspace is a different matter and usually does mean the token's user cannot see that workspace or report.
Nodes start failing with HTTP 402 partway through a run
That is the request quota, not a billing problem, despite the status code. Toggl allows 30 requests per hour per user per organization on Free, 240 on Starter and 600 on Premium for any call that names a workspace or organization, and answers 402 once the window is spent. It is not retryable until the window moves, so a retry loop makes it worse. Run Toggl Track: Get API Quota to see what remains and how many seconds until reset, then restructure the workflow to spend less: replace a loop over projects or people with one call to Toggl Track: Run Summary Report or Toggl Track: Run Project Users Summary Report, and replace per record edits with Toggl Track: Bulk Edit Time Entries. Adding a quota check with a branch at the top of the workflow turns this from a mid run failure into a decision.
A single node returns 402 even though the quota looks fine
Toggl also uses 402 when the workspace's plan does not include the feature being called, which is why a quota check can look healthy while one node keeps failing. The usual candidates are the six task nodes, since Toggl lists tasks as a Starter feature, and Toggl Track: Archive Client and Toggl Track: Restore Client, which Toggl's API reference documents as premium workspaces only. Fields rather than whole nodes can also trip this: billable rates and estimates need Starter, and labor costs, fixed fee projects and project templates need Premium, and Toggl warns that a request carrying a field the plan does not include can be rejected rather than ignored. Confirm the workspace's plan with Toggl Track: Get Workspace or Toggl Track: List My Organizations, which reports the pricing plan name, then either clear the gated field or move the workflow to a workspace on a plan that includes it.
Requests fail with HTTP 429
That is the second, independent limiter: a leaky bucket applied per API token and IP address, separate from the hourly quota. Toggl says a safe window is one request per second and asks clients to sleep until the bucket empties, suggesting a back off of a few minutes rather than an immediate retry. In practice this shows up when several workflows share one credential and run at the same time, or when a loop fires nodes back to back. Space the calls out, stagger schedules that share a credential, and prefer the single request reporting and bulk nodes over sequences of small calls.
A node fails with 403 right after another node created the thing it refers to
This is Toggl's eventual consistency rather than a permissions fault, and it is the reason a workflow can fail once and then succeed unchanged. Toggl states that a newly created organization, workspace, project or group needs time to appear in your session, and recommends waiting two to five seconds and retrying up to three times before using it. The classic case is Toggl Track: Create Project chained straight into Toggl Track: Add Project Member. Put a short delay between the create and the first use of the new id, and set the following node to retry rather than treating the first failure as final.
A detailed report is missing entries you know exist
The most likely cause is truncation at the page size rather than a filter problem. Toggl pages the detailed report using cursor values it returns in response headers, and a canvas node cannot read response headers, so there is no way to request a second page from the previous node's output. The node exposes the page size as a first class field for exactly this reason. Raise it so a single call covers the window you are asking about, and treat a result whose row count is exactly the page size as truncated rather than complete, because that is what it usually means. If the window is genuinely too large for one call, split it into shorter windows and combine the results, which also spreads the request cost across quota windows.
Updating or removing a workspace member hits the wrong person, or 404s
Almost always the wrong id. A workspace membership row carries its own id and a separate user_id, and they are different numbers in the same payload. Toggl Track: Update Workspace Member and Toggl Track: Remove Workspace Member take the membership id, while the flat rows from Toggl Track: List Workspace Users carry the user id. Source the value from Toggl Track: List Workspace Members for those two nodes, which is what their pickers do by default, and check that any id you are templating in from an earlier step came from the membership lister rather than the user lister.
A bulk edit reported success but only some records changed
That is documented behaviour rather than a fault. Toggl states that the patch executes partially when some records fail, with no transaction and no rollback, so a run in which several entries were rejected still answers HTTP 200. The response body carries a success array of ids and a failure array of ids with reasons, and that pair is the only record of what happened. Branch on those arrays rather than on the status code, log the failure array so the reasons survive, and feed the failed ids into a follow up step instead of re-running the whole batch, which would re-apply changes that already landed.
Time totals are wildly wrong, in the billions
A running timer is in the window. Toggl stores a running entry's duration as the negative of its start time in UNIX seconds, which is a marker rather than a length, so adding it to real durations throws the total out by nine digits. Filter entries whose stop is empty out of any arithmetic, or take totals from the reporting nodes, which count real durations. If the point of the workflow is to catch open timers, Toggl Track: Get Running Time Entry answers that directly, and Toggl Track: Stop Time Entry closes one. Check that something is actually running before stopping it, because stopping an already stopped entry is an error rather than a no operation.
A task or workspace list node returns nothing useful, or the rows are in an unexpected place
Two separate causes. If the task nodes return errors rather than rows, check the plan: Toggl lists tasks as a Starter feature and a Free workspace cannot use them at all. If the rows are simply not where a downstream step expects them, note that Toggl Track: List Workspace Tasks is the one lister in this connector that does not return a bare array: its rows sit nested under a data key alongside page, per_page and total_count, while every other lister here answers with a flat array. Point the downstream reference at the nested path, or use Toggl Track: List Project Tasks instead, which is already scoped to a project and returns a flat array. That is also why the task pickers are fed from the per project lister rather than the workspace wide one.

Toggl Track is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products