Let Claude Handle Your Tempo Timesheets

General
1

What I Built

An MCP server that lets Claude directly read and manage Tempo Timesheets through the official Tempo API. Instead of manually logging hours, updating billing accounts, or cleaning up duplicate worklogs, you can simply ask Claude in natural language and it handles the rest with full CRUD and bulk operations.

GitHub: GitHub - sanjeev7e/tempo-mcp · GitHub

If you use Tempo Timesheets, you probably know the routine.

Friday afternoon rolls around. You open your calendar, cross-reference Jira issues, figure out which account each entry belongs to, fix missing attributes, delete duplicates, and hope everything adds up before submitting your timesheet.

None of this is difficult.

It’s just repetitive.

So I built tempo-timesheet-mcp—an MCP server that gives Claude direct access to the Tempo Timesheets API, turning timesheet management into a conversation instead of a sequence of manual clicks.

Instead of navigating the Tempo UI, you can simply ask Claude:

“Log my meetings for this week.”

Or:

“Find duplicate worklogs and remove them.”

Or even:

“Fix all worklogs that are missing the billing account.”

Claude handles the API calls, and you get structured results showing exactly what happened.

What is tempo-timesheet-mcp?

Tempo provides a comprehensive REST API, but there isn’t a native way for AI assistants to use it.

tempo-timesheet-mcp bridges that gap by exposing Tempo’s v4 API as MCP tools that Claude Desktop and Claude Code can invoke directly.

The server is written in TypeScript, runs on Bun, and supports the complete worklog lifecycle.

Account operations

Manage Tempo accounts with tools to:

  • List accounts
  • Fetch account details
  • Search accounts
  • Retrieve account links

Worklog operations

Everything you’d expect:

  • Create
  • Read
  • Update
  • Delete
  • Search

You can also retrieve worklogs by:

  • User
  • Jira issue
  • Project
  • Account

Bulk operations, the real time saver

The biggest productivity gain comes from bulk operations.

The server supports:

  • Native bulk creation (up to 50 worklogs against a single issue)
  • Parallel bulk creation across multiple Jira issues
  • Parallel bulk updates
  • Parallel bulk deletes

Every bulk tool accepts a configurable concurrency value (1–20, default 5), allowing you to balance speed with API limits.

More importantly, every operation returns structured results:

  • Total attempted
  • Successful
  • Failed
  • Individual success/error for every item

So if 18 worklogs succeed and 2 fail, you know exactly which two failed and why—without digging through logs or guessing.

Why I built it

In our workflow, worklogs aren’t always created manually.

Some originate from automated pipelines:

  • Git commits
  • Calendar synchronization
  • Internal tooling

Those entries often arrive missing required metadata such as billing accounts or other Tempo attributes.

Correcting dozens of worklogs every week isn’t technically challenging.

It’s simply repetitive work.

This is exactly the kind of task an AI assistant should handle—as long as it has real tool access instead of trying to infer or hallucinate actions.

That’s what tempo-timesheet-mcp provides.

Claude isn’t pretending to manage Tempo.

It’s actually reading and writing worklogs through the official API.

Getting started

You’ll need:

1. Generate an API token

Navigate to:

Tempo → Settings → Data Access → API Integration

Generate a new API token.

2. Configure Claude

Add the server to your MCP configuration:

{
  "mcpServers": {
    "tempo": {
      "command": "bun",
      "args": ["run", "/absolute/path/to/src/index.ts"],
      "env": {
        "TEMPO_API_TOKEN": "...",
        "TEMPO_BASE_URL": "https://api.tempo.io"
      }
    }
  }
}

Tempo provides regional endpoints.

Use whichever matches your organization:

  • https://api.eu.tempo.io
  • https://api.us.tempo.io
  • https://api.tempo.io

My weekly workflow

This is the workflow I use almost every week.

1. Read my calendar

Claude fetches my Google Calendar events for the week in IST, ignoring meetings I’ve declined.

2. Compare against Tempo

It retrieves my existing worklogs so it knows what’s already logged and avoids duplicates.

3. Classify each event

Claude maps every calendar block to:

  • Jira issue
  • Tempo billing account

For example:

  • Daily standups → CC-3 / CUST_PRODUCT_Billable
  • Product tactical meetings → CC-6 / CUST_PRODUCT_Billable
  • Timesheet administration → CNE-389 / CLOUD_NATIVE_ENG_OPEX

4. Create or update worklogs

New entries are created in bulk.

Existing entries missing required attributes are updated in bulk.

Since Tempo requires complete payloads for updates, Claude automatically sends the full worklog.

5. Review results

Every bulk operation returns a detailed summary.

If a worklog fails because of an invalid account, incorrect billableSeconds, or a permission issue, I immediately know which one needs attention.

6. Clean up duplicates

Occasionally duplicate worklogs appear because of overlapping automation.

Claude identifies them and removes them with a single bulk delete operation.

The entire process now takes a couple of chat prompts instead of 20–30 minutes of manually navigating Tempo every Friday.

Give it a try

Once connected, you can ask Claude things like:

  • “Show my worklogs for this week.”
  • “Create 15-minute worklogs for issue CC-3 from Monday to Friday.”
  • “Find worklogs missing the account attribute and update them.”
  • “Delete these duplicate worklogs.” (paste the IDs)

This project started as a way to eliminate repetitive timesheet administration, but it’s also been a great example of what MCP enables: giving AI assistants secure, structured access to the tools we already use every day.

If you’re using Tempo and Claude, I’d love to hear your feedback—or ideas for additional endpoints.

1 Like