Provides tools for controlling Toggl time tracking, including starting/stopping timers, viewing current and daily time entries, managing projects, deleting entries, and generating weekly time summaries with breakdowns by day and project.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Toggl MCP Server show me my time entries for today"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Dead simple MCP (Model Context Protocol) server for Toggl time tracking. Control your Toggl timer directly from Claude, ChatGPT, or any LLM that supports MCP.
⏱️ Start/stop timers
📊 View current timer
📈 Get today's time entries
🗂️ List projects
🗑️ Delete time entries
Related MCP server: Toggl MCP Server
Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"toggl": {
"command": "npx",
"args": ["-y", "@louis030195/toggl-mcp"],
"env": {
"TOGGL_API_KEY": "your-toggl-api-key"
}
}
}
}# Install globally in user scope with API key
claude mcp add -s user toggl npx -e TOGGL_API_KEY=your-toggl-api-key -- -y @louis030195/toggl-mcpGo to Toggl Track Profile
Scroll down to "API Token"
Click "Click to reveal" and copy your token
Once configured, you can use natural language to control Toggl:
"Start tracking work on the MCP server project"
"Stop the current timer"
"What am I currently tracking?"
"Show me today's time entries"
"List all my projects"
toggl_startStart a new timer with a description and optional project.
toggl_stopStop the currently running timer.
toggl_currentGet information about the currently running timer.
toggl_todayGet all time entries for today with total duration.
toggl_projectsList all projects in your workspace.
toggl_deleteDelete a time entry by its ID.
toggl_weeklyGet weekly time tracking summary with total hours and breakdowns.
Parameters: week_offset (optional, number)
0 = current week
-1 = last week
-2 = two weeks ago, etc.
Returns:
Total hours for the week
Daily breakdown (hours per day)
Project breakdown (hours per project)
Full list of entries
toggl_last_weekConvenience function to get last week's time tracking summary (equivalent to toggl_weekly with week_offset: -1).
# Clone the repo
git clone https://github.com/louis030195/toggl-mcp.git
cd toggl-mcp
# Install dependencies
npm install
# Build
npm run build
# Run locally
TOGGL_API_KEY=your-api-key npm startMIT
Get the currently running time entry
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states what the tool does but doesn't disclose behavioral traits like error handling (what if no entry is running), authentication needs, rate limits, or response format. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose with no unnecessary words. It's front-loaded and perfectly sized for its simple function, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 params, no output schema), the description adequately covers the basic purpose. However, with no annotations and no output schema, it lacks details on behavior and return values, which could be important for an agent to use it correctly in edge cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add param info, which is appropriate, earning a baseline 4 as it doesn't detract from the complete schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get the currently running time entry' clearly states the action (Get) and resource (currently running time entry). It distinguishes from siblings like toggl_start (starts entry), toggl_stop (stops entry), and toggl_today (lists today's entries) by focusing specifically on the active entry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing to check what time entry is currently active, which provides clear context. However, it doesn't explicitly state when not to use it (e.g., for historical entries) or name alternatives like toggl_today for broader queries, missing full explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete a time entry by ID
| Name | Required | Description | Default |
|---|---|---|---|
| entry_id | Yes | ID of the time entry to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a time entry, implying a destructive mutation, but doesn't cover critical aspects like whether deletion is permanent, requires specific permissions, has side effects (e.g., affecting reports), or what happens on success/failure. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words. It front-loads the key action ('Delete') and resource, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., irreversibility, error handling), usage context, and expected outcomes, leaving the agent with insufficient guidance to use the tool safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'entry_id' fully documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. The baseline score of 3 reflects adequate coverage via the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and the resource ('a time entry by ID'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools, but the verb 'Delete' distinguishes it from read operations like 'toggl_current' or 'toggl_today'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing time entry ID), exclusions, or relationships with sibling tools like 'toggl_stop' (which might stop a running entry).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get last week's time tracking summary
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Get[s]' data, implying a read-only operation, but doesn't clarify aspects like authentication requirements, rate limits, error handling, or the format of the returned summary. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function with zero wasted words. It is appropriately sized for a no-parameter tool and front-loaded with the essential information, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavioral traits (e.g., data format, error cases) and usage context relative to siblings. For a read operation with no structured output documentation, more completeness would be beneficial but not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter details, as there are none to document. It appropriately focuses on the tool's purpose without unnecessary parameter explanations, earning a high baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('last week's time tracking summary'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'toggl_today' or 'toggl_weekly', which likely provide similar time tracking summaries for different time periods.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'toggl_today' (for today's summary) or 'toggl_weekly' (for a weekly summary that might be configurable), leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all projects in the workspace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states a read operation ('List'), implying it's non-destructive, but doesn't disclose behavioral traits such as pagination, rate limits, authentication needs, or what 'all' entails (e.g., archived projects). This is inadequate for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without any wasted words. It's front-loaded and appropriately sized for a simple list operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema), the description is minimally complete for a basic list function. However, without annotations or output schema, it lacks details on return format or behavioral constraints, leaving gaps in context for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 for not introducing confusion or redundancy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List all') and resource ('projects in the workspace'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'toggl_current' or 'toggl_today', which might also involve project data, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't specify if this is for getting a comprehensive list versus filtered views available in other tools, or mention prerequisites like workspace context. This leaves the agent without usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start a new time tracking entry
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | Description of the task | |
| project_name | No | Optional project name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool starts tracking but doesn't cover aspects like whether it requires authentication, what happens if an entry is already running, or if there are rate limits. This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is minimal but covers the basic action. For a mutation tool with two parameters, it should ideally include more about behavioral context or output expectations, but it meets a bare minimum for clarity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents both parameters thoroughly. The description adds no additional meaning about parameters beyond implying they're used for starting an entry, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Start') and resource ('a new time tracking entry'), making the tool's purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'toggl_current' or 'toggl_stop', but the verb 'Start' implies creation of a new entry versus managing existing ones.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention using 'toggl_stop' to end tracking or 'toggl_current' to check active entries, leaving the agent to infer usage from tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop the currently running timer
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action ('stop') but doesn't disclose behavioral traits like whether this requires authentication, what happens if no timer is running (e.g., error or no-op), or the response format. This is a mutation tool with zero annotation coverage, leaving significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—it directly states the tool's action without unnecessary words. It's front-loaded and appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with no annotations and no output schema), the description is incomplete. It lacks details on error conditions, response behavior, or integration with sibling tools, making it inadequate for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't mention parameters, which is correct for a zero-param tool, earning a baseline score above minimum viable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('stop') and the target ('currently running timer'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'toggl_current' or 'toggl_start', but the verb 'stop' inherently contrasts with 'start'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when there's an active timer to stop, but doesn't explicitly state when to use this tool versus alternatives like 'toggl_current' (which might check status) or 'toggl_start' (which starts a timer). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get today's time entries with total duration
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but doesn't clarify aspects like authentication requirements, rate limits, error handling, or the format of returned data (e.g., list structure, timezone handling). For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Get today's time entries with total duration.' It is front-loaded with the core purpose and includes no wasted words. Every part of the sentence contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavioral traits and usage context. Without annotations or output schema, the description should ideally provide more context on data format or limitations, but it meets the basic requirement for a simple read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate. A baseline of 4 is applied for tools with zero parameters, as there's nothing to compensate for, and the description correctly avoids unnecessary parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get today's time entries with total duration.' It specifies the verb ('Get'), resource ('today's time entries'), and additional output ('with total duration'). However, it doesn't explicitly differentiate from siblings like 'toggl_current' or 'toggl_last_week,' which might also retrieve time entries but for different timeframes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'toggl_current' (likely for current/ongoing entries) or 'toggl_last_week' (for past week), leaving the agent to infer usage based on tool names alone. No explicit when/when-not or alternative recommendations are included.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get weekly time tracking summary with total hours, daily/project breakdowns
| Name | Required | Description | Default |
|---|---|---|---|
| week_offset | No | Number of weeks before current week (0 = current, -1 = last week) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves a summary (implying read-only), but doesn't mention authentication needs, rate limits, error conditions, or what the output format looks like (e.g., JSON structure). For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It avoids unnecessary words and directly states what the tool does. However, it could be slightly more structured by explicitly separating the summary components (e.g., 'Provides a weekly summary including total hours, daily breakdowns, and project breakdowns').
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of time tracking data and the lack of annotations and output schema, the description is incomplete. It doesn't explain the return format (e.g., whether it's a detailed report or aggregated totals), how data is structured, or potential limitations (e.g., only shows tracked time, excludes billable vs. non-billable). For a tool with no structured output documentation, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter-specific information beyond what's in the schema, which has 100% coverage for the single parameter 'week_offset'. The schema description fully explains the parameter's purpose and values (e.g., 0 for current week, -1 for last week). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get weekly time tracking summary with total hours, daily/project breakdowns'. It specifies the verb ('Get'), resource ('weekly time tracking summary'), and what the summary includes. However, it doesn't explicitly differentiate from siblings like 'toggl_last_week' or 'toggl_today', which likely provide similar time tracking data for different timeframes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'toggl_last_week' (which might overlap for week_offset=-1) or 'toggl_today', nor does it specify prerequisites or exclusions. The agent must infer usage from the tool name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.1toggl_currenttoggl_deletetoggl_last_weektoggl_projectstoggl_starttoggl_stoptoggl_todaytoggl_weeklyScored across 8 tools
Each tool has a clearly distinct purpose with no ambiguity: toggl_current and toggl_stop handle the active timer, toggl_start initiates tracking, toggl_delete removes entries, and the summary tools (toggl_today, toggl_last_week, toggl_weekly) provide different timeframes. The tools toggl_projects stands alone for workspace management. There is no overlap in functionality that would cause misselection.
All tools follow a consistent 'toggl_verb' or 'toggl_noun' pattern with clear, descriptive names. The naming is uniform across all eight tools, using lowercase with underscores, making it predictable and easy to understand. There are no deviations in style or convention.
With 8 tools, the server is well-scoped for time tracking and project management. Each tool earns its place by covering essential operations like starting/stopping timers, viewing summaries, managing entries, and listing projects. This count is neither too sparse nor overwhelming for the domain.
The tool set provides strong coverage for core time tracking workflows, including CRUD operations (create via toggl_start, read via summary tools, delete via toggl_delete) and project listing. A minor gap exists in updating time entries (e.g., modifying descriptions or projects), but agents can work around this by deleting and recreating entries. Overall, it supports most common user actions without dead ends.
WHOOP recovery, strain, sleep and workouts in Claude via official WHOOP OAuth. Free, open source.
Manage projects, tasks, time tracking, and team collaboration through natural language.
Track billable time from your AI chat: timers, entries, reports, CSV export. All data stays local.
Read time entries, projects, clients, tasks and invoices; log and update tracked time.
