Best time tracking tools for developers in 2026

For most developers, Toggl Track is the safest pick: a timer button inside Jira, GitHub and GitLab, no screenshots on any plan, and a free tier. WakaTime is the one to add if you want editor time logged automatically from VS Code or a JetBrains IDE. Everhour fits teams that want hours written back into Jira issues, Timen is the free option with the same start-button-on-the-issue idea, and Hubstaff is the one to avoid unless your employer specifically wants screenshots and activity scores.

Developers have a different problem with time tracking than most people. The work already lives in an issue tracker and a repository, so a tool that asks you to retype "PROJ-412 fix flaky checkout test" into a separate app will be abandoned within a week. The good tools put a start button on the issue or the pull request. The very good ones can log time without you touching anything, which is what WakaTime and Timely do in different ways.

There is a second question developers ask before anyone else does: what does this thing record, and who can see it? Some of the tools below are honest time trackers. Others are monitoring products with a timer attached, and the difference is not always obvious from the pricing page. So this list covers the four things the search for "time tracking software for developers" is really asking about: Jira, GitHub and GitLab integrations, automatic versus manual tracking, remote and contract work, and which tools take screenshots or score your activity.

Quick picks

If you only read one section, this is the decision in six lines.

• Best overall: Toggl Track, for a timer inside Jira, GitHub and GitLab with no monitoring on any plan.
• Best automatic editor tracking: WakaTime, with plugins for VS Code, JetBrains IDEs, Neovim, Xcode and around ninety other editors.
• Best for time written back into Jira: Everhour, whose native integrations keep tracked hours on the issue.
• Best free option: Timen, free for the whole team with a Chrome extension that covers Jira, GitHub, GitLab and about 160 other tools.
• Best automatic tracking without an IDE plugin: Timely, whose Memory app records app and window activity privately on Mac and Windows.
• Best for contractors who invoice: Harvest, which turns hours into invoices and refuses to do screenshots.

What developers need from a time tracker

A developer's time tracker has to survive context switching between an editor, a terminal, a browser tab full of pull requests and a call. The tools that survive share four traits.

• A start button where the work is. Inside the Jira issue, the GitHub pull request or the GitLab merge request, with the title copied into the entry. Every tool here except WakaTime, Timely and Hubstaff does this through a browser extension.
• A clear answer on monitoring. Whether the tool takes screenshots, records app and URL activity, and whether an admin can see it. This is the section most comparison articles skip, and it is the one developers care about most.
• Automatic capture that stays private. WakaTime's editor plugins and Timely's Memory app both log time without a timer, and both keep the raw data to the person it belongs to. That is a different thing from a manager's activity feed.
• A path from hours to money. Contract developers need billable rates and invoices. Employed developers usually do not, and should not pay for them.

What developers do not need is an activity score. Typing rate and mouse movement say nothing about whether a difficult bug got fixed, and a tool that scores them tends to change how people work for the worse.

How we compared these tools

A short note on method, so you can weigh the calls below.

• Documentation, not a test drive. The integration and monitoring claims come from each vendor's help centre or documentation, read in September 2026. We did not run all nine tools side by side, and we do not pretend to have.
• Prices from vendor pages. Every plan and price was checked on the vendor's own help centre or pricing page in September 2026. Where a first-year price differs from the renewal price, both are stated. Prices change; confirm before you buy.
• Reviews summarised, not quoted. The G2 ratings are the aggregate score on each product's G2 page in September 2026. The review paragraphs paraphrase recurring themes across G2 and Capterra rather than quoting one reviewer.
• Order. Roughly how well each tool fits a working developer, with integration depth and monitoring stance weighted most. Timen appears where it fits, not at the top.

Time tracking tools for developers comparison table

The fast version. "Monitoring" means screenshots or app and URL tracking that someone other than you can see.

Best time tracking tools for developers in 2026

The notes below go tool by tool. Each one covers the integrations that matter to developers, what the tool records, the current price, and what reviewers on G2 and Capterra keep saying. If your team is choosing between a timer and a timesheet habit, the manual entry vs timers trade-off is worth settling first.

1. Toggl Track - best overall for developers

Best for: Developers and small engineering teams who want a timer on the issue and a vendor that has ruled out monitoring in writing.

• Pricing: Free plan for a limited number of users; Starter $9 per user/month billed annually or $12 monthly; Premium $18 per user/month billed annually ($14 in the first year on the annual plan) or $20 monthly. Checked September 2026.
• Rating: 4.6/5 on G2

Toggl Track's browser extension adds a start timer link inside Jira, GitHub and GitLab, among many other tools, and copies the item's title into the entry. You enable each integration in the extension's settings, so it only runs where you tell it to. The Windows and macOS apps have an optional Timeline feature that records every program and website you view for more than ten seconds, and Toggl's documentation is explicit that this data is visible only to you, not to workspace admins.

The limits are on the Jira side and on billing. Jira Sync, which maps Jira projects, issues and labels onto Toggl projects, tasks and tags, is a Premium feature and only imports from Jira into Toggl; nothing goes back. Billable rates start on the Starter plan, so a freelancer who wants rates on the free tier will not get them.

Pros

• Toggl's support site states plainly that no Toggl app takes screenshots or monitors app usage.
• Timer button in Jira, GitHub and GitLab through the browser extension.
• Timeline gives you a private record of the day to reconstruct forgotten time.
• Web, desktop and mobile apps, all on the free plan.

Cons

• Jira Sync is Premium only and one-directional.
• Billable rates and project estimates need a paid plan.

What users say about Toggl Track

If the Premium price is what stops you, the Toggl Track alternatives list covers the cheaper routes.

2. WakaTime - automatic time from your editor

Best for: Developers who want coding time logged without a timer, and teams who want per-project and per-language coding metrics.

• Pricing: Free plan with one week of dashboard history; Basic $9/month or $8.25/month billed annually ($99/year); Premium $14/month or $12.83/month billed annually ($153.96/year); Team $21 per developer/month or $19.25 billed annually. Checked September 2026.
• Rating: 4/5 on G2, from a small number of reviews

WakaTime is the only tool here that works inside the editor rather than around it. Its open-source plugins for VS Code, IntelliJ and the other JetBrains IDEs, Neovim, Xcode, Android Studio, Visual Studio, Cursor and even Claude Code and the terminal send a heartbeat every couple of minutes while you edit, on file switches and on save, and stop after fifteen minutes of inactivity by default. The result is a dashboard of coding time by project, language, branch and file with nothing to start or stop.

Privacy is handled at the plugin: file contents are never sent, only file paths and project names, and config options let you hide project and file names before anything leaves your machine. The trade-off is scope. WakaTime sees editor time and nothing else, so code review in a browser, meetings and reading documentation are invisible to it. Invoicing from tracked time is a paid feature, and the free plan's one-week dashboard window is the single most repeated complaint.

Pros

• Fully automatic; plugins for roughly ninety editors and IDEs.
• Never sends file contents; project and file names can be obfuscated.
• Metrics by project, language and branch that no timer-based tool can produce.
• Coding activity is stored forever even on the free plan, and unlocks when you upgrade.

Cons

• Only editor time; nothing outside the IDE is tracked.
• Free dashboard is limited to one week of history.
• Team pricing is high next to general-purpose trackers.

What users say about WakaTime

3. Clockify - the cheapest team option with a Jira and GitHub extension

Best for: Small engineering teams that want a working tracker with Jira, GitHub and GitLab buttons for as little money as possible.

• Pricing: Free for up to 5 users; Basic $3.99 per user/month billed annually or $4.99 monthly; Standard $5.49 or $6.99; Pro $7.99 or $9.99; Enterprise $11.99 or $14.99. Checked September 2026.
• Rating: 4.5/5 on G2

Clockify's Chrome and Firefox extension starts a timer from inside Jira, GitHub, GitLab, Trello, Asana and a long list of other web apps, and the free plan includes integrations and API access. The desktop apps for Windows, macOS and Linux have an auto tracker that records programs and websites you use for more than ten seconds, and Clockify's documentation says only the person using the app can see those activities or turn them into entries.

The catch for developers is that Clockify also sells screenshots, on the Pro plan, as an admin-enabled feature. It is off unless your workspace owner turns it on, but it exists, which is a different position from Toggl's. The free plan was also capped at five users in a change Clockify made earlier, so larger teams now pay per seat.

Pros

• Lowest paid entry price of any tool here.
• Extension covers Jira, GitHub and GitLab on the free plan.
• Auto tracker is private to the user and runs on Linux as well as Mac and Windows.
• Both timer and timesheet modes for teams that log in batches.

Cons

• Screenshots are available on Pro, so the tool can become monitoring software if an admin decides so.
• Free plan now stops at five users.
• Interface is functional rather than polished, and reviewers report fiddly edits.

What users say about Clockify

Teams deciding between the two big timer-first tools usually settle it with Toggl Track vs Clockify; the wider Clockify alternatives list covers the rest.

4. Everhour - hours that stay on the Jira or GitHub issue

Best for: Teams that want time, estimates and budgets to live inside Jira, GitHub, GitLab or Linear rather than in a separate app.

• Pricing: Free for up to 5 seats with no integrations; Team $8.50 per user/month billed annually with a 5-seat minimum, about 15% less than monthly billing; 14-day trial. Checked September 2026.
• Rating: 4.7/5 on G2

Everhour calls Jira, GitHub, GitLab and Linear native integrations, meaning the timer, the logged time and the estimate are embedded in the issue's own interface and synced both ways, rather than a floating button that copies a title. For a team that reports time against issues, that is the whole point, and it is why Everhour ranks above Clockify here despite costing more.

Two things to know. The free plan has no integrations at all, so a developer team gets nothing useful until the Team plan, which has a five-seat minimum. And Everhour has an optional screenshot feature on Team plans: it only captures while a timer is running, it records nothing else, it is off unless an admin enables it, and members can delete their own screenshots. There is still no mobile app.

Pros

• Native two-way integrations with Jira, GitHub, GitLab and Linear.
• Estimates and budgets visible on the issue where developers already look.
• Screenshots are opt-in, timer-only, and deletable by the person in them.
• Billing, budgets and invoicing on the Team plan for agencies.

Cons

• Free plan excludes integrations, and the paid plan starts at five seats.
• No mobile app.
• Screenshots exist as a feature, even if off by default.

What users say about Everhour

The Everhour alternatives list is the next stop if the seat minimum is the problem.

5. Timen - free, with a start button on the issue

Best for: Developers and small teams who want the Toggl-style button on Jira, GitHub and GitLab pages, plus reports and invoices, for free.

• Pricing: Free for the whole team, every feature included, no per-user pricing. Checked September 2026.

Full disclosure: this is our tool, so weigh it accordingly. Timen's Chrome extension puts a start button on the Jira issue, the GitHub issue or pull request, and the GitLab issue or merge request, and takes the title, the issue number and, where the page shows them, the project name and labels into the entry the moment you click. Around 160 tools are supported, including Linear, Bitbucket, YouTrack, Sentry and self-hosted GitLab, Jira or Redmine through a custom domain setting. Every site is off until you switch it on, and Chrome asks you to approve that specific site, so the extension does not run, read or know about any page you have not enabled.

There is no monitoring of any kind: no screenshots, no activity levels, no app or URL tracking, and nothing that admins can see beyond the entries you save. The hours land in the same timer, calendar, reports and invoices the rest of the team uses, and you can also start, stop and log time by talking to Claude or ChatGPT through Timen's MCP connection. The integrations page lists what connects today.

Now the honest part. Timen has no IDE plugin, so it cannot log editor time the way WakaTime does. There is no automatic or background tracking at all; a timer runs because you started it. There are iPhone, Android and Mac apps, but no Windows app and no Firefox or Safari extension. The extension copies the issue into Timen but does not post time back to Jira worklogs or GitHub, so if your process needs hours on the Jira issue itself, Everhour or Hubstaff are the tools built for that.

Pros

• Free with every feature, including reports and invoicing.
• Start button on Jira, GitHub and GitLab pages, with per-site permissions you control.
• No screenshots, activity scores or app tracking, on any plan, because there is only one plan.
• Imports from Toggl Track, Harvest, Clockify, Timely, Hubstaff and Jibble, and sends invoices to QuickBooks, Xero, FreshBooks and Wave.

Cons

• No IDE plugin and no automatic tracking.
• Chrome and Chromium browsers only; no desktop app; mobile apps not yet shipped.
• Does not write time back into Jira or GitHub.
• Newer product with little third-party review coverage.

Why teams pick Timen

6. Timely - automatic tracking that stays yours

Best for: Developers who forget timers and want the day reconstructed automatically from real app activity, without anyone else seeing the raw record.

• Pricing: No free plan, 14-day trial; Starter $9 per user/month billed annually or $11 monthly (up to 5 users, 20 projects); Premium $16 or $20 (up to 50 users, unlimited projects); Unlimited $22 or $28. Checked September 2026.
• Rating: 4.8/5 on G2

Timely's Memory app for macOS and Windows records the app name, window title, browser URL and sometimes the file name of whatever you are working in, along with how long. That covers your IDE, your terminal and your browser without a plugin for any of them. You then drag those memories into time entries, or let Timely's suggestions do it. The vendor's privacy documentation is unusually direct: Memory never records keystrokes, screenshots or audio, skips private browsing, and the timeline is visible only to you unless you choose to share an entry.

Timely lists Jira, GitHub and Linear as integrations and GitLab as an app Memory tracks, though its integrations page does not describe how deep each connection goes, so check the specific one you need before paying. The real cost is the price: there is no free plan, the Starter tier caps at five users and twenty projects, and the plans that suit a team are the most expensive general trackers on this list.

Pros

• Automatic capture across every app, not just the editor.
• No keystrokes, screenshots or audio, and Memory data is private to you by policy.
• Reconstructs forgotten time better than any manual tool.
• Polished interface and strong support scores in reviews.

Cons

• No free plan, and the per-user price is the highest here after Hubstaff's Enterprise tier.
• Starter plan limits of 5 users and 20 projects are tight for a team.
• Integration depth for Jira and GitHub is not documented in detail.

What users say about Timely

For the other automatic approach, Timely vs RescueTime sets the two side by side.

7. Harvest - for contract developers who invoice

Best for: Freelance and contract developers whose hours turn into invoices, and who want a vendor that has ruled out screenshots.

• Pricing: Free for 1 seat and 2 active projects; Teams $9 per seat/month ($108 per seat/year billed annually); Enterprise $14 per seat/month. Since 2025 Harvest also bills usage fees for invoices, projects, clients and tasks beyond the base allowance. Checked September 2026.
• Rating: 4.3/5 on G2

Harvest's developer story is two integrations and one refusal. The official Harvest app on the Atlassian Marketplace adds a timer to every Jira Cloud issue, fills the notes with the issue key and title, and links the timesheet entry back to the issue. The Chrome, Firefox and Edge extension does the same for GitHub issues and pull requests. And Harvest's help centre states that it does not take screenshots, does not track apps or websites, and does not monitor messages; what an employer sees is the timesheet you submit.

The reason it sits this far down is money. The free plan is one person and two projects, GitLab is not on the integrations list, and the usage-based fees introduced after the Bending Spoons acquisition make the real cost harder to predict than the $9 headline suggests.

Pros

• Best hours-to-invoice path of the tools here.
• Official Jira Cloud app and a browser extension for GitHub.
• Explicit no-screenshots, no-app-tracking policy in the help centre.
• Mac and iOS apps included on the free plan.

Cons

• Usage fees on top of the seat price.
• No GitLab integration listed.
• Free plan is too small for anyone with more than two projects.

What users say about Harvest

The pricing change is covered in detail in Harvest pricing changes, and the Harvest alternatives list covers what to move to.

8. TimeCamp - reporting depth with optional activity tracking

Best for: Teams that want a cheap tracker with Jira, GitHub and GitLab integrations and are comfortable that admins can turn on activity tracking.

• Pricing: Free plan with unlimited users and projects; Starter $3.99 per user/month billed annually; Premium $6.99 billed annually or $9.99 monthly; Ultimate $9.99 billed annually or $13.99 monthly. Checked September 2026.
• Rating: 4.7/5 on G2

TimeCamp integrates with Jira Cloud and Jira Server, GitHub and GitLab, importing issues and branches as tasks so time is tracked against them, and its Chrome extension adds one-click timers inside those tools. The free plan has unlimited users, which no other paid-tier tool here matches, and the reporting is deeper than Toggl's or Clockify's.

The monitoring stance is the thing to read carefully. On Premium and Ultimate the desktop app can register the names of every website and application you use while working; by default administrators and supervisors can view those activities for the people they manage, and it takes a specific setting to make them private. Screenshots are an Ultimate-plan module that only an account administrator can enable. Neither is on by default, but both are a switch away. One more caution: TimeCamp's own FAQ pages disagree about how many integrations each plan includes, so confirm with them which plan your Jira or GitHub connection needs.

Pros

• Jira Cloud and Server, GitHub and GitLab integrations that import issues as tasks.
• Free plan with unlimited users and projects.
• Reporting and categorisation deeper than the timer-first tools.
• Users can mark private time that is excluded from activity tracking.

Cons

• Activity tracking is visible to admins by default once enabled.
• Screenshots exist on the Ultimate plan.
• Reviewers regularly mention bugs and reliability issues.

What users say about TimeCamp

The TimeCamp alternatives list is the next read if the activity tracking is a deal-breaker.

9. Hubstaff - deep Jira, GitHub and GitLab sync, with monitoring you cannot remove

Best for: Employers of remote or outsourced developers who have decided they want screenshots, activity levels and time written back to Jira. Not for developers choosing for themselves.

• Pricing: Free plan for one seat; Starter $4.99, Grow $7.50, Team $10 and Enterprise $25 per seat/month billed annually, all with a 2-seat minimum on paid plans. Integrations: none on Starter, one on Grow, unlimited on Team. Checked September 2026.
• Rating: 4.4/5 on G2

On integrations alone, Hubstaff is strong. Jira issues on company-managed projects sync as tasks and tracked time is written back to Jira as time entries. GitLab issues sync the same way and time appears in the issue's time tracking section. GitHub issues become to-dos and, when an issue is closed, the time spent is posted back as a comment, though only organisation accounts can connect. All of it runs through the desktop app.

The same desktop app is what developers object to. Hubstaff captures screenshots on every plan, including the free one, with limits of 500 per seat per month on Starter and 1,500 on Grow before becoming unlimited on Team, alongside activity levels derived from keyboard and mouse use and app and URL tracking. There is an add-on for up to ten screenshots every ten minutes, and a silent app add-on that tracks in the background on company-owned devices. None of this can be removed; it is the product. Hubstaff's own pricing page describes it as proof of work, and that is the accurate framing.

Pros

• Two-way Jira and GitLab sync with time written back to the issue.
• Payroll, budgets and scheduling in one place for outsourcing setups.
• Low per-seat price on the Starter plan.

Cons

• Screenshots and activity scoring on every plan, free included.
• Integrations need Grow for one and Team for more.
• GitHub integration excludes personal accounts; Jira integration excludes team-managed projects.
• Reviewers report billing disputes and surprise renewals.

What users say about Hubstaff

Developers handed Hubstaff by an employer usually end up at the Hubstaff alternatives list, which is written for exactly that conversation.

Which time tracking tools take screenshots or monitor activity?

Four of the nine tools have no monitoring feature at any price. Three have one that an admin can switch on. One has it on by default and cannot switch it off. WakaTime is a special case: no screenshots, but it does send your file paths and project names to its servers, which you can obfuscate in the config. Everything below is from each vendor's own documentation, checked September 2026.

If you are a developer picking a tool for yourself, the top rows are the safe ones. If you are being asked to install one by an employer, the table tells you what to ask about: not whether the feature exists, but whether it is on, and who has the switch.

Automatic or manual tracking: which suits developers?

Automatic tracking wins on completeness and manual tracking wins on meaning, and most developers end up wanting a bit of both. The trick is to be clear which problem you are solving.

Automatic capture solves the forgotten timer. WakaTime does it inside the editor, so it knows you spent forty minutes in one file on one branch, which no other tool can tell you. Timely's Memory does it across the whole machine, so it also sees the pull request you reviewed in Chrome and the call you took in Slack. Toggl's Timeline and Clockify's auto tracker sit in between: a private log of apps and sites you can turn into entries afterwards. What none of them know is why. Forty minutes in a file could be the fix or the failed attempt before the fix, and the entry that matters to a client or a sprint retrospective is the one that says "PROJ-412 fix flaky checkout test".

Manual tracking, done well, is a single click on the issue. That is what the browser extensions from Toggl, Clockify, Harvest, TimeCamp and Timen and the embedded timers from Everhour all do, and it produces entries that already carry the issue key, the project and often the labels. It fails when the click is forgotten, which is why the practical answer for many developers is a start button on the issue for the record, plus something automatic as a safety net for the day you forgot.

A warning about the word "automatic" on vendor pages. Hubstaff and TimeCamp also describe activity tracking as automatic. It is, but its audience is your manager, not you. Automatic tracking that is private to the person doing the work is a productivity feature; automatic tracking visible to someone else is monitoring, however it is labelled.

Time tracking for Jira, GitHub and GitLab: how each tool connects

There are three levels of integration, and the marketing rarely says which one you are getting. A button on the page copies the issue title into your tracker. A sync imports issues as tasks so you track against them. A write-back posts the hours into the issue itself. Here is where each tool lands, from the vendors' documentation in September 2026.

• Toggl Track: button on Jira, GitHub and GitLab pages through the extension; Jira Sync on Premium imports projects, issues and labels into Toggl but sends nothing back.
• Clockify: button on Jira, GitHub and GitLab pages through the Chrome or Firefox extension, on the free plan.
• Everhour: native integrations with Jira, GitHub, GitLab and Linear that embed the timer and synced time in the issue. Team plan only.
• Timen: button on Jira, GitHub and GitLab pages, plus self-hosted instances through custom domains, through the Chrome extension. No write-back.
• Harvest: official Jira Cloud app that puts a timer on the issue and links the entry back; GitHub issues and pull requests through the browser extension. No GitLab.
• TimeCamp: Jira Cloud and Server, GitHub and GitLab imported as tasks, plus extension buttons; plan requirements are inconsistent across TimeCamp's own FAQs.
• Hubstaff: Jira issues on company-managed projects and GitLab issues sync as tasks with time written back; GitHub organisation issues sync and get a time comment on close. Grow for one integration, Team for more.
• WakaTime and Timely: no issue-level button. WakaTime tracks by repository and branch from inside the editor; Timely lists Jira, GitHub and Linear as integrations without documenting the depth.

The rule of thumb: if the requirement is "hours must appear on the Jira issue", you need Everhour or Hubstaff. If the requirement is "the entry must say which issue it was", every extension-based tool does that already, and the free ones do it as well as the paid ones.

What changes for remote and contract developers?

Remote work changes who is asking for the data, and contract work changes what happens to the hours afterwards. The tool choice follows from those two facts.

A remote employee is often handed a tracker rather than choosing one, and the question is what it records. If the employer proposes Hubstaff or turns on TimeCamp's activity tracking, the reasonable counter is a tool that produces the same timesheet without the screenshots: Toggl Track, Everhour if they want Jira write-back, or Timen if the budget is zero. Every one of those gives a manager hours by project and person, which is what most managers actually want; the screenshots are a proxy for trust that the timesheet already provides.

A contract developer needs billable rates and an invoice, and needs the entry to say which ticket it was so the client does not query it. Harvest is the strongest on the invoice side, Timen does rates, reports and invoices for free, and Everhour handles billing on the Team plan. WakaTime is popular with freelancers for evidence, a per-project coding report that backs up the invoice, but it is not enough alone, because the client is also paying for the review, the call and the deploy that never touched the editor. The workflow that holds up is a button on the ticket for the billable record, WakaTime or Timely as the safety net, and a weekly check that the two roughly agree. How that review works in practice is covered in weekly billable time review.

If you live in the terminal

None of the nine tools above is a command-line tracker, and for some developers that is disqualifying. The option worth knowing is Timewarrior, free and open-source software from the Taskwarrior authors that tracks time with "timew start" and "timew stop", tags intervals, prints day, week and month reports in the terminal, and exposes its data as JSON for scripts. It installs from Homebrew, apt, dnf, pacman and Nix, and its 1.10.0 release shipped in August 2026, so it is actively maintained. Everything stays on your machine, which is the most private option on this page.

It is deliberately not in the ranked list. There is no vendor screenshot, no G2 or Capterra review base to summarise, no sync between machines beyond copying the data folder yourself, and no invoicing, so it cannot be compared on the same terms. Watson, the other well-known CLI tracker, has not had a release since 2022, so Timewarrior is the one to pick. The common pattern is Timewarrior for the developer's own record and one of the tools above for whatever the team or client needs to see.

Which tool should you choose?

Match the tool to the requirement you actually have, not the longest feature list.

You want a timer on the issue and no monitoring, ever -> Toggl Track. Clockify if the price matters more and you trust your admin to leave screenshots off.

You want coding time logged with no effort -> WakaTime for the editor, Timely if you want the whole machine covered and can pay for it.

Hours must appear in Jira, GitHub or GitLab -> Everhour. Hubstaff only if the employer has already decided on monitoring and you have no say.

You invoice for your hours -> Harvest for the deepest invoicing, Timen for rates, reports and invoices at no cost.

You want it free for the whole team -> Timen, with the caveat that it is manual, Chrome-only, and does not write time back to Jira. TimeCamp's free plan is also unlimited, but read its monitoring section first.

You want nothing to leave your machine -> Timewarrior, and accept that you will export a report by hand when someone needs one.

FAQ

The questions developers ask once they have a shortlist.

Which time tracking tools do not take screenshots?

Toggl Track, Timely, Harvest, WakaTime and Timen have no screenshot feature at all. Clockify, Everhour and TimeCamp can take screenshots, but only on a paid plan and only after an admin switches the feature on. Hubstaff captures screenshots on every plan, including the free one.

Can a time tracker log hours back into Jira?

Hubstaff writes tracked time back to Jira worklogs on company-managed projects, and Everhour syncs time into the Jira issue through its native integration. Toggl Track's Jira Sync only imports issues into Toggl, and the browser-extension timers from Clockify, Harvest and Timen copy the issue title into the entry but do not post time back to Jira.

Is WakaTime enough on its own for a freelance developer?

It covers editor time well, but nothing else. Code review in a browser, calls, planning and reading documentation never reach WakaTime, and the free plan only shows one week of dashboard history. Freelancers who invoice by the hour usually pair it with a manual tracker, or pick a tool that handles billing directly.

What does a remote developer actually need from a time tracker?

Four things: a start button where the work already is, such as a Jira issue or GitHub pull request; a clear statement of what the tool records and who can see it; a way to fix a forgotten timer without a fight; and, for contractors, a path from tracked hours to an invoice. Activity scores and screenshots are a management preference, not a developer need.

Conclusion

Developer time tracking comes down to two questions: where does the timer live, and who sees what it records. Toggl Track answers both well and is the default. WakaTime is the add-on for automatic editor time, Everhour is the pick when hours have to land on the issue, and Harvest is the pick when they have to land on an invoice.

Timen belongs on the list for a team that wants the button-on-the-issue workflow, reports and invoices without paying per seat, as long as it does not need IDE plugins, automatic capture or Jira write-back. And Hubstaff belongs on it only so you know what you are looking at when an employer suggests it. If you are still torn between the two mainstream timers, Toggl Track vs Clockify settles that one.