Connect Hourtick to ChatGPT: Track Time and Manage Workspace Tasks

If you need to connect Hourtick to ChatGPT to automate time tracking, manage workspace tasks, or run complex P&L reports, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's function calling capabilities and Hourtick's backend APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Hourtick to Claude or explore our broader architectural overview on connecting Hourtick to AI Agents.

Giving a Large Language Model (LLM) read and write access to a specialized time-tracking and project management platform is a significant engineering challenge. You must handle complex bulk updates, navigate idiosyncratic command structures for timers, and parse deeply nested reporting objects. Every time Hourtick updates its API schema, your custom server code must be patched and redeployed.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Hourtick, connect it natively to ChatGPT, and execute complex time and task workflows using natural language.

The Engineering Reality of the Hourtick API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Hourtick's highly specific API is exceptionally painful.

If you decide to build a custom MCP server for Hourtick, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Hourtick:

Idempotent Event-Driven Time Commands

Unlike standard SaaS platforms where you might simply POST /timers to start tracking time, Hourtick utilizes an event-sourced command architecture. Managing time entries requires issuing specific command payloads - start, restart, stop, create, edit, delete, or restore - accompanied by an idempotent commandId. This prevents duplicate entries if a network request drops and is retried. Your MCP server must generate unique command IDs on the fly and map the LLM's natural language intent ("start a timer for the Acme project") into this strict command structure.

Atomic Bulk Operations

Hourtick supports bulk updating time entries, but it enforces strict transactional boundaries. If you attempt to patch 500 time entries and a single entry is marked as stale, submitted, approved, or invoiced, the entire batch fails atomically. If you build your own MCP integration, you must script complex pre-flight checks or write fallback logic to isolate the offending entry. Truto handles the schema discovery and exposes the exact validation requirements directly to the LLM via JSON schema.

Untyped Analytics Payloads

When you request a report from Hourtick (e.g., an agent cost reconciliation report or a team P&L summary), the API frequently returns dynamic, untyped JSON objects whose fields are not enumerated in the upstream OpenAPI spec. Static typing in your custom MCP server will break when these dynamic keys shift based on the report's grouping criteria. Truto's dynamic tool generation passes these raw JSON objects back to the LLM unaltered, allowing the model's intelligence to parse the unstructured data effectively.

Step 1: Generating a Hourtick MCP Server

Before connecting to ChatGPT, you need to generate an MCP server that acts as a secure proxy to your Hourtick account. This server handles authentication, pagination, schema resolution, and protocol mapping automatically.

Truto provides two distinct paths to generate this server: through the graphical UI or programmatically via the REST API.

Method A: Via the Truto UI

If you prefer a visual interface, you can generate the server directly from your dashboard.

1. Log into your Truto dashboard and navigate to the integrated account page for your Hourtick connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can optionally filter which methods (e.g., read, write) or tags (e.g., tasks, reports) this specific server should expose.
5. Click Create and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<secure_token>). Treat this URL like a password.

Method B: Via the API

For teams building automated onboarding flows or dynamic agent orchestration, you can generate the MCP server programmatically. Truto validates the configuration, generates a secure cryptographic token, stores it in a distributed key-value store, and returns a ready-to-use URL.

Make a POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Hourtick for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["time", "tasks", "reports"]
    }
  }'

The API will return a JSON response containing your securely scoped URL:

{
  "id": "mcp_123abc",
  "name": "Hourtick for ChatGPT",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["time", "tasks", "reports"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Step 2: Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with ChatGPT. The protocol dictates that the client (ChatGPT) connects to the server, completes a handshake, and requests the available tools.

Method A: Via the ChatGPT UI

If you are using the ChatGPT desktop application (Pro, Plus, Business, Enterprise, or Education accounts):

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable the Developer mode toggle (MCP support requires this feature flag).
3. Under the custom connectors or MCP servers section, add a new server.
4. Provide a recognizable name (e.g., "Hourtick Ops").
5. Paste your Truto MCP URL into the Server URL field and click Add.

ChatGPT will immediately ping the server, complete the initialization handshake, and list the available Hourtick tools in its context.

Method B: Via Manual Config File

If you are running a custom headless ChatGPT client or using an orchestration framework that mimics standard desktop setups, you can define the server locally using an SSE transport configuration file.

Create a JSON file (e.g., hourtick_mcp.json) outlining the server connection commands:

{
  "mcpServers": {
    "hourtick_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your_secure_token>"
      ]
    }
  }
}

Your MCP client will execute this command to establish a Server-Sent Events (SSE) connection bridging your local runtime to Truto's edge infrastructure.

Hourtick Hero Tools

Truto automatically generates detailed MCP tools by combining Hourtick's endpoint definitions with its underlying JSON schema. Here are 6 of the highest-leverage tools your AI agent can now call.

1. List All Hourtick Time Entries

Retrieve a comprehensive list of time entries within a specified date range. This includes any currently running timers. It returns critical data such as duration, notes, billable status, and associated project IDs.

Usage Note: This is the primary tool for auditing where a team's time went over a specific period. The LLM must supply from and to date parameters.

"Fetch all my time entries for last week. Summarize the total billable hours and list any entries that are missing notes."

2. Create a Hourtick Command (Start/Stop/Edit Timers)

This is the engine for active time tracking. It accepts a commandId and a command payload to start, restart, stop, create, edit, delete, or restore a time entry. Starting a timer automatically stops any currently running timer.

Usage Note: Ensure the LLM generates a unique commandId string. If editing or deleting, the LLM must provide the expectedVersion to prevent concurrent write conflicts.

"Stop my current timer, and start a new timer for the 'Website Redesign' project. Set the notes to 'Drafting landing page copy'."

3. Hourtick Time Entries Bulk Update

Update one or many time entries simultaneously by applying a single patch object (altering notes, project ID, spent date, etc.) to every listed entry ID.

Usage Note: Operations are strictly atomic. The LLM can patch up to 500 entries per request, but you should prompt it to verify entry status first to ensure none are locked or invoiced.

"Find all time entries logged yesterday under the 'Internal Research' project and bulk update them to be non-billable."

4. List All Hourtick Reports

Generate detailed P&L and time reports for a specified period. Managers can see team scopes, while administrators can access full cost, profit, and uncosted seconds data.

Usage Note: The response contains highly nested totals, groups, and entries objects. The LLM excels at flattening this data into readable summaries.

"Run a Hourtick report for Q1. Break down the total profit margin by client, and flag any projects where our uncosted seconds exceeded our budget."

5. Create a Hourtick Work Item

Instantiate a new task on the Hourtick board. This creates a standard task record with a title, status, priority, and optional labels.

Usage Note: The only strictly required field is the title, making it exceptionally easy for the LLM to spin up tasks based on chat context.

"Create a high-priority work item titled 'Deploy database migrations' and assign the label 'DevOps'."

6. Create a Hourtick Chat Message

Push a message directly into a Hourtick chat channel. This tool accepts a channel_id and a body (up to 20,000 characters).

Usage Note: Mentioning an AI agent's UUID in the body will automatically queue an agent session downstream in Hourtick's internal systems.

"Post an update in the engineering channel summarizing the time report you just ran, and ask the team to verify their unlogged hours."

For a complete list of all available operations - including AI provider syncing, invoice management, and presence tracking - view the Hourtick Integration Page.

Workflows in Action

Connecting Hourtick to ChatGPT transforms a static chat interface into a dynamic workspace orchestrator. Here are two concrete scenarios showing exactly how the tools chain together.

Scenario 1: The Agency Project Manager

An agency manager needs to audit a project's profitability, adjust incorrect time logs, and notify the team of the results - all from a single prompt.

"Run the Q2 report for the 'Alpha Redesign' project. If any time entries are marked as billable but have no notes, bulk update them to append 'Needs review' to the notes field. Then, post a summary of the project's profit margin to the management chat channel."

Step-by-step execution:

1. list_all_hourtick_reports: The agent fetches the Q2 report, filtering for the 'Alpha Redesign' project.
2. list_all_hourtick_time_entries: The agent pulls the raw time entries to identify those lacking notes.
3. hourtick_time_entries_bulk_update: The agent constructs a patch payload and applies 'Needs review' to the offending entry IDs.
4. create_a_hourtick_chat_message: The agent formats the profit margin data extracted from the report and posts the summary to the specified channel ID.

sequenceDiagram
  participant User as "ChatGPT User"
  participant LLM as "ChatGPT"
  participant Truto as "Truto MCP Server"
  participant Hourtick as "Hourtick API"

  User->>LLM: "Run Q2 report, fix empty notes, notify management."
  LLM->>Truto: call_tool("list_all_hourtick_reports")
  Truto->>Hourtick: GET /reports
  Hourtick-->>Truto: { report_data }
  Truto-->>LLM: JSON result
  LLM->>Truto: call_tool("list_all_hourtick_time_entries")
  Truto->>Hourtick: GET /time_entries
  Hourtick-->>Truto: { entries }
  Truto-->>LLM: JSON result
  LLM->>Truto: call_tool("hourtick_time_entries_bulk_update")
  Truto->>Hourtick: PATCH /time_entries
  Hourtick-->>Truto: { updated }
  Truto-->>LLM: JSON result
  LLM->>Truto: call_tool("create_a_hourtick_chat_message")
  Truto->>Hourtick: POST /chat/messages
  Hourtick-->>Truto: { message }
  Truto-->>LLM: JSON result
  LLM-->>User: "Report analyzed, entries patched, management notified."

Scenario 2: The Developer Flow

A developer wants to wrap up their day without manually clicking through the Hourtick UI to manage their timers and tasks.

"Stop my current timer. Create a new work item for 'Write documentation for the auth service' and start a timer against it. Finally, fetch my total hours for today."

Step-by-step execution:

1. create_a_hourtick_command: The agent generates a commandId and issues a stop command to halt the active timer.
2. create_a_hourtick_work_item: The agent creates the new task and retrieves its ID.
3. create_a_hourtick_command: The agent issues a start command, passing the newly acquired project/task ID.
4. list_all_hourtick_time_entries: The agent queries today's entries, sums the durationSeconds, and reports the total to the user.

Security and Access Control

Exposing your company's time and billing data to an LLM requires strict security constraints. Truto's MCP servers are designed with granular access controls baked into the edge architecture.

• Method Filtering: When creating the server, you can explicitly define which HTTP methods are permitted. If you only want ChatGPT to analyze data, set methods: ["read"]. All write tools (create, update, delete) will be entirely stripped from the server's capabilities.
• Tag Filtering: You can restrict the server to specific functional areas. Passing tags: ["time", "reports"] ensures the LLM cannot access chat channels or billing integrations.
• require_api_token_auth: By default, the MCP URL acts as a bearer token. For enterprise deployments, setting this flag to true forces the client to pass a secondary Truto API token via the Authorization header, verifying the identity of the specific human operator before executing a tool.
• expires_at: You can assign a time-to-live expiration when generating the server. Once the timestamp is reached, Truto's scheduled cleanup processes automatically purge the token from the distributed key-value store, instantly severing access without manual intervention.

A Note on Architecture and Rate Limits

Truto’s architecture ensures that your data is never cached or stored at rest within the integration layer. Every tool execution is proxied directly to Hourtick, and query parameters merge with body parameters into a flat, predictable input namespace that LLMs can easily navigate.

Factual note on rate limits: It is critical to understand how API limits are handled in this architecture. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Hourtick API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (whether that is your custom MCP client or an orchestrator built on top of ChatGPT) is solely responsible for implementing retry and exponential backoff logic.

By leveraging Truto's dynamic tool generation, you eliminate the overhead of manually coding schemas, tracking API changes, and managing OAuth lifecycles. Your LLM gets secure, structured access to Hourtick, and your engineering team gets to focus on core product features.