Linear does not include built-in time tracking. To log hours against Linear issues, use a third-party time tracking integration, add a browser extension that injects timers into the Linear UI, or build a custom integration using Linear’s GraphQL API.
Your engineering team ships fast with Linear. The issue tracker is minimal, keyboard-driven, and keeps the backlog clean. But when Friday arrives and the project manager asks how many hours went into the client sprint, the room goes quiet. Linear tracks what got done — it does not track how long it took. That gap between delivery velocity and billable hours is the source of revenue leakage for every agency, consultancy, and freelance developer who uses Linear for project management. This guide covers the three practical approaches to adding time tracking to Linear, the technical details behind each, and how to pick the right fit.
Why Does Linear Not Have Native Time Tracking?
Linear was built with a specific design philosophy: speed and simplicity over feature breadth. The team behind Linear has stated repeatedly that time tracking falls outside their core scope. Every feature added to an issue tracker introduces friction — extra fields, extra clicks, extra decisions. Linear’s position is that stripping out everything non-essential is what makes actions take three to four seconds instead of eight to twelve in competing tools.
Who Needs Time Tracking in Linear?
Many engineering teams that use Linear do not bill by the hour. They work in story points, measure cycle velocity, and report on throughput. For these teams, the absence of time tracking is a feature, not a gap.
But agencies, consultancies, and freelancers who chose Linear for its speed still need time data. Client billing requires hours. Capacity planning requires knowing how long work actually takes versus the estimate. Tracking billable hours is non-negotiable for professional services — and without it built in, Linear forces a workflow split: issues in one tool, time in another.
The friction shows up downstream. Developers context-switch between Linear and a timer app. Entries get forgotten. The timesheet at the end of the week is a reconstruction from memory rather than a record of what happened. The question is not whether to track time alongside Linear, but which method creates the least disruption.
What Third-Party Time Tracking Integrations Work with Linear?
Three categories of tools fill the gap. Each makes a different trade-off between friction, accuracy, and setup effort.
Dedicated Time Tracking Tools with Linear Sync
Several standalone time tracking tools connect to Linear through OAuth or API key authentication. The pattern is consistent: the time tracker pulls your Linear issues and projects into its own interface, and you log time against synced issues from the tracker’s UI.
How it works: You authorise the time tracking tool to read your Linear workspace. Issues, projects, and team labels sync on a schedule — typically every five to fifteen minutes. When you start a timer in the tracker, you select a Linear issue from a dropdown. The logged entry stays in the tracker’s database, linked to the Linear issue ID.
Advantages:
- Purpose-built time tracking UI with reporting, invoicing, and approval workflows
- Historical data stays in a system designed for billing
- Works for teams that track time across multiple tools, not just Linear
Disadvantages:
- Another subscription and another tab to manage
- Sync delays mean the issue list in the tracker may lag behind Linear by minutes
- Developers must leave the Linear UI to log time, which increases the chance of forgotten entries
Browser Extensions That Add Timers to Linear
A lighter approach is a browser extension that injects a start/stop timer button directly into the Linear issue view. The extension reads the current issue ID from the page URL, attaches the running timer to that issue, and stores entries either locally or in a connected time tracking backend.
How it works: Install the extension, authenticate with your time tracking account, and a small timer widget appears on every Linear issue page. Click start when you begin work, click stop when you finish or switch tasks. The extension handles the mapping between the Linear issue and the time entry.
Advantages:
- Low friction — you stay in the Linear interface
- No sync delay because the issue context is read directly from the page
- Setup takes under five minutes
Disadvantages:
- Relies on manual start and stop — if you forget to press the button, the entry is wrong
- Does not capture offline work, mobile work, or work done outside the browser
- Extension compatibility can break when Linear updates its UI
Automation Platforms That Connect Linear to Time Tracking via Webhooks
Workflow automation tools can bridge Linear and a time tracking tool without a direct integration. The typical setup uses Linear webhooks to trigger actions in the automation platform, which then creates or stops time entries in the tracker.
How it works: You configure a Linear webhook that fires when an issue status changes — for example, when an issue moves to “In Progress.” The automation platform receives the webhook, extracts the issue ID and assignee, and starts a timer in the connected time tracking tool. When the issue moves to “Done” or “In Review,” another webhook stops the timer.
Advantages:
- Semi-automatic — no manual timer clicks required
- Customisable logic: you can filter by team, label, or project
- Works with any time tracking tool that has an API
Disadvantages:
- Accuracy depends on status changes reflecting real work, which is not always true
- A developer who works on an issue without moving it to “In Progress” logs zero hours
- Requires initial setup and ongoing maintenance as workflows evolve
Choosing between these three depends on team size and billing complexity. A solo freelancer may find a browser extension sufficient. An agency billing multiple clients needs a dedicated tracker with invoicing from tracked hours.
How Do You Build Custom Time Tracking with the Linear API?
Linear provides a public GraphQL API at https://api.linear.app/graphql that gives full access to issues, projects, cycles, teams, and status changes. For teams with development capacity, the API opens up three custom approaches.
Approach 1: Calculate Time-in-Status from Issue History
Linear’s API exposes issue history, including status transitions. By querying when an issue moved to “In Progress” and when it left that status, you can calculate the wall-clock time spent in each state.
query IssueHistory($issueId: String!) {
issue(id: $issueId) {
history {
nodes {
createdAt
fromState { name }
toState { name }
}
}
}
}Limitation: This method assumes the status reflects actual work. A developer who moves an issue to “In Progress” on Monday morning but does not start coding until Tuesday afternoon shows two days of effort instead of a few hours. It measures cycle time, not work time — useful for capacity planning but unreliable for billing.
Approach 2: Build a Lightweight Time Logging UI
A more accurate approach is to build a small web application that lets developers log time manually, storing entries in your own database and linking them to Linear issue IDs. Linear webhooks notify your app when issues are created, updated, or completed, keeping the issue list current without polling.
Authentication uses personal API keys generated in Linear under Account > Security & Access > Personal API Keys. Pass the key as an Authorization header:
curl -X POST https://api.linear.app/graphql \
-H "Content-Type: application/json" \
-H "Authorization: lin_api_xxxxxxxxxxxx" \
-d '{"query": "{ viewer { id name } }"}'This approach gives you full control over the data model. You can add fields that Linear does not support — billable versus non-billable hours, client codes, approval status — and build reports tailored to your billing workflow.
Approach 3: Sync Linear Issues to a Time Tracker via API
The third path combines the API with an existing time tracking tool. A scheduled script pulls new and updated issues from Linear and pushes them into the tracker’s API. Developers log time in the tracker against synced issues. A second script pulls completed time entries back and attaches them as comments or custom properties on the Linear issue.
This is the most common pattern for teams that already use a time tracker and want to avoid switching tools. The integration code is typically under 200 lines and runs on a cron schedule.
API rate limits: Linear’s API enforces rate limits per application. Batch your queries where possible — request multiple issues in a single query rather than one request per issue. The API returns a 429 Too Many Requests response when limits are hit, so build in retry logic with exponential backoff.
How Do You Map Linear Issues to Time Entries?
Getting time data into a system is half the problem. The other half is making that data useful for billing and reporting. Clean mapping between Linear issues and time entries is what separates an accurate invoice from a guess.
Use Linear Issue IDs as the Linking Key
Every Linear issue has a unique identifier (e.g., ENG-142). Use this as the foreign key in your time tracking system. When a developer logs 2 hours against ENG-142, your reporting pipeline can pull the issue title, project, and labels from Linear’s API to enrich the time entry with context.
Map Linear Projects to Client Billing Codes
If your team works across multiple clients, map each Linear project to a client billing code in your time tracker. This lets you generate per-client invoices directly from time data without manual sorting.
Use Linear Labels for Billable and Non-Billable Tags
Create a pair of labels in Linear — billable and non-billable — and apply them to issues at creation. Your time tracking integration reads the label and categorises the entry automatically. This prevents the common problem of logging hours against internal work and accidentally including them on a client invoice.
Align Time Periods with Linear Cycles
Linear’s cycles map naturally to sprint boundaries. Align your time tracking reporting periods with cycle start and end dates to produce sprint-level time reports. This gives engineering managers a direct comparison between estimated effort (from story points or cycle goals) and actual hours logged — the data needed for improving future estimates.
Cross-Reference for Gaps
Run a weekly check: every billable issue should have logged time, and every time entry should have a valid Linear issue ID. Entries without issues are orphaned hours that cannot be billed. Issues without entries are untracked work that erodes project profitability. Both gaps need to be caught before the invoice goes out.
Key Takeaway
Linear intentionally omits time tracking to stay fast. Use a third-party integration, browser extension, or the GraphQL API to add time logging without leaving Linear.
Frequently Asked Questions
Does Linear have built-in time tracking?
No. Linear does not include native time tracking. The team has kept time logging out of the product deliberately to maintain speed and simplicity. You need a third-party integration, browser extension, or custom API build to log hours against Linear issues.
How do I track time against Linear issues?
Use one of three approaches: connect a dedicated time tracking tool that syncs Linear issues via API, install a browser extension that adds a timer button to the Linear UI, or build a custom integration using Linear’s GraphQL API at https://api.linear.app/graphql.
Can I use Linear issue status changes to estimate time spent?
Yes, approximately. You can query Linear’s API for issue history and calculate the time an issue spent in each status (such as “In Progress”). However, this measures cycle time, not active work time — it assumes the developer was working the entire time the issue held that status, which is rarely accurate.
Will Linear add time tracking in the future?
Linear has not announced plans for native time tracking. Their public changelog through early 2026 focuses on API enhancements and AI tooling rather than time management features. Third-party integrations remain the recommended approach.
How do I connect Linear to my billing system?
Map Linear projects to client billing codes in your time tracker, use Linear labels to tag issues as billable or non-billable, and align reporting periods with Linear cycles. Use the issue ID as the linking key between systems so that every time entry traces back to a specific piece of work.