Quick Answer — connect time tracking to xero invoicing: Authorise your time tracking tool to access your Xero organisation via OAuth, map your projects to Xero contacts and tracking categories, configure which entries are billable, then let the integration push approved time as draft invoice line items. Setup takes 20–40 minutes and eliminates 2–4 hours of monthly manual invoice creation.
You track developer time in one tool and generate invoices in Xero manually — copying hours, calculating totals, and hoping nothing gets lost in translation. That gap is where billing errors live. A direct integration eliminates it: approved time flows to Xero as draft invoice line items automatically, and you review rather than rebuild.
This guide covers how time-to-Xero integrations work, which tools support native Xero sync, a step-by-step setup walkthrough, and the five pitfalls that catch teams off guard after they go live.
Why connect time tracking to Xero?
Manual invoice creation from timesheets is a compounding problem. It is slow (2–4 hours per month for a small team), error-prone (copy-paste mistakes lead to billing discrepancies and client disputes), and delayed (every extra day between work done and invoice sent costs cash flow).
The structural problem is that two separate tools hold the same information with no enforced relationship between them. The time tracker knows hours, rates, and project attribution. Xero knows client contacts, payment terms, and tax categories. When a human bridges the gap manually, accuracy depends entirely on how tired and busy that person is.
A connected system solves this at the source:
- Audit trail from time entry to invoice line item. Every billed hour can be traced back to the exact time entry that generated it. Clients can verify the work; you can defend every figure.
- Billing completeness. Manual invoicing routinely misses small time entries — a 15-minute call here, a quick fix there. Automated sync captures everything that is marked billable without relying on someone to remember it. See how to structure this with multiple client projects running in parallel.
- Faster cash collection. Teams that automate time-to-invoice typically cut their billing cycle by three to five days. That is measurable improvement in accounts receivable, not theory. The invoice-from-tracked-hours workflow covers the full conversion from approved time to sent invoice.
Xero’s REST API makes integration straightforward for most time tracking tools. OAuth authentication is the standard entry point, and Xero exposes invoices, contacts, tracking categories, and line items through well-documented endpoints. Accounting firms that manage multiple client accounts benefit most from this automation — see time and billing software for accountants for tool comparisons tailored to that context.
How time-to-Xero integrations work (data flow)
Understanding the data flow helps you configure the integration correctly and diagnose problems when they arise. The five-step process is consistent across tools:
- Capture time. The developer records time — manually, via a timer, or automatically from git activity, calendar events, or IDE telemetry.
- Mark entries as billable. Time entries are reviewed and approved. The integration only syncs entries flagged as billable; internal time stays out of Xero.
- Sync to Xero as draft invoices. Approved billable entries are pushed to Xero as draft invoice line items against the matching Xero contact. The invoice is not sent — it is draft, ready for your review.
- Review and adjust in Xero. You open the draft invoice, verify line items and totals, add any fixed-fee items, and send to the client.
- Payment tracking and reconciliation. Payment is recorded in Xero and reconciled against the original time entries. The billing cycle is complete.
The key data that transfers in each sync: Xero contact (client), invoice date, line item description, quantity (hours), unit price (rate), and total amount. What does not transfer automatically: Xero tracking categories for department or job costing (these require explicit mapping), tax rates (Xero applies its own tax rules), and custom fields beyond standard line items.
Time tracking tools that integrate with Xero
| Tool | Xero integration type | Sync frequency | Best for |
|---|---|---|---|
| Harvest | Native, built-in | On-demand (batch) | General use, agencies |
| Toggl Track | Third-party (Zapier/Make) | Real-time (via Zapier) | Teams already using Zapier |
| Clockify | Native (paid plans) | On-demand | Budget-conscious teams |
| Keito | Native, git-based | Real-time | Dev teams billing by code activity |
| TSheets (QuickBooks Time) | Indirect (QuickBooks only) | N/A | Not recommended for Xero |
Harvest has the most mature Xero integration: it maps time entries to invoices natively, supports multiple currencies, and handles Xero tracking categories through explicit mapping. It is the default choice for general-purpose agencies.
Toggl Track does not have a native Xero connector. Integration requires Zapier or Make, which works but adds latency and a second monthly subscription cost.
Clockify launched native Xero integration on its paid tiers. Setup is straightforward for teams already using Clockify, but time capture is manual — there is no automatic detection.
Keito captures developer time from git commits, pull requests, and code reviews — the activity patterns that actually define how developers work. That captured time flows directly to Xero via native integration, so invoices reflect actual code delivery, not a developer’s best recollection at the end of the week. For software teams whose billable output is primarily code rather than hours sitting at a desk, this distinction matters for invoice accuracy. The Keito Xero integration setup guide walks through the OAuth authorisation and contact mapping in detail.
How to Connect Time Tracking to Xero Invoicing
This walkthrough covers the general flow. The specific UI differs per tool, but the configuration steps are consistent.
Step 1: Choose a tool with native Xero support. Third-party connector setups (Zapier, Make) work but add operational complexity. For a billing workflow that needs to be reliable at end-of-month, native integration is lower maintenance.
Step 2: Authorise the Xero connection via OAuth. In your time tracking tool’s integrations settings, select Xero and click Connect. You will be redirected to Xero’s authorisation page. Log in with your Xero organisation credentials, review the requested permissions (typically: read contacts, create and update invoices, read tracking categories), and approve. The connection is complete — your time tool now has an authenticated session token for your Xero organisation.
Step 3: Map projects to Xero contacts. This is the most important configuration step. Each project in your time tracker must be linked to the corresponding Xero contact (client). Without this mapping, the integration does not know which invoice to create entries against. Most tools offer a dropdown that lists your existing Xero contacts; select the right one per project. Create any missing contacts in Xero first, then return to this step.
Step 4: Configure rate cards. Your time tracking tool and Xero must agree on hourly rates. If they diverge — Xero thinks the rate is £150/hour, your time tool has £120/hour — the invoice totals will be wrong. Decide which system is the source of truth for rates and configure the other to match. Most teams treat Xero as authoritative since it is where the client contract lives; the time tool inherits rates from Xero via the integration.
Step 5: Set up billing rules. Define which time entries should create invoice line items. Typical rules: only entries marked “billable”, only approved entries (not pending review), entries after a specific project start date. Set a default for new time entries to avoid manual billable-flag management.
Step 6: Choose sync frequency. Most integrations offer on-demand sync (you trigger it manually before invoicing) or automatic sync on a schedule (daily or weekly). On-demand sync is safer when you are first getting started — you can verify the draft invoices before the next sync runs. Switch to scheduled sync once you trust the mapping configuration.
Step 7: Test with a draft invoice. Before going live, create a small batch of test time entries, mark them billable, run a sync, and open the resulting Xero draft invoice. Check: the client is correct, line item descriptions match the time entry notes, hours and rates are right, the total is accurate. Fix any mapping issues now, not after your first real client invoice.
Step 8: Set up error notifications. Configure your time tool to alert you on sync failures — unmapped clients, rate mismatches, or API errors. These alerts should go to whoever is responsible for billing, not just the developer who set up the integration.
Common pitfalls and how to avoid them
Pitfall 1: Rate mismatches. Your time tool has one rate for a client; Xero has a different rate in the invoice template. The integration picks one and the total is wrong. Fix: establish a single source of truth for rates before connecting the tools. Most teams use Xero as the authority — rates live on the Xero contact, and the time tool reflects them.
Pitfall 2: Duplicate line items. Running a sync twice, or syncing entries that were already included in a previous invoice, generates duplicate line items. Fix: use unique entry IDs and idempotent sync logic (the tool should check whether an entry has already been synced before creating a new line item). Most native integrations handle this; verify before relying on it.
Pitfall 3: Unmapped clients. A new project is created in your time tool but no one links it to a Xero contact. When the sync runs, those entries fail silently or create entries against a default “Unknown” contact. Fix: make contact mapping a required step in your project creation workflow. Some tools enforce this with a validation error; others allow unmapped projects and create orphaned time entries.
Pitfall 4: Currency mismatches. Your time tool is configured in USD; the Xero invoice is in GBP. The integration pushes amounts in USD, and Xero either rejects them or converts at the wrong rate. Fix: configure currency per client, both in your time tool and in the Xero contact settings. Agree which system handles FX conversion (typically Xero, since it holds the client’s contract currency).
Pitfall 5: Tax calculation conflicts. Your time tool calculates tax on billable amounts; Xero applies its own tax rules. The line items arrive pre-taxed, and Xero adds tax again. Fix: send pre-tax amounts only. Let Xero handle all VAT, GST, or sales tax calculation — that is where your tax rates, exemptions, and compliance rules should live.
Key takeaways
Connecting time tracking to Xero removes 2–4 hours of monthly manual invoice work and closes the gap where billing errors occur. The data flow is consistent across tools: capture time, approve and mark billable, sync to Xero as draft invoices, review, send. For dev teams, git-based time capture paired with Xero sync gives the most accurate pipeline — code activity generates time entries automatically, and those entries become invoices without manual intervention.
Before going live, test the integration with draft invoices and verify the four mapping points that break most setups: client-to-contact, rates, currencies, and billing rules. If your workflow extends beyond invoicing to payroll, see time tracking payroll integration for how the same time data can feed payroll runs. Freelancers wanting to close the full billing loop can combine Xero sync with accepting invoice payments online via Stripe — no separate payment tool required.
FAQ
How do I connect time tracking to Xero invoicing?
To connect time tracking to Xero invoicing: authorise your time tracker via Xero’s OAuth flow, map each project to the corresponding Xero contact, mark time entries as billable, then run a sync to push approved entries to Xero as draft invoice line items. Most native integrations complete the initial setup in 20–40 minutes, after which billing runs automatically without manual data entry.
Which time tracking tool has the best Xero integration?
Harvest has the most mature native Xero integration for general-purpose use. For software development teams where billable time is primarily code activity, Keito’s git-based capture combined with native Xero sync provides more accurate invoicing — time is measured from actual code delivery rather than manual timers.
Can I automatically create Xero invoices from time entries?
Yes. Most tools with native Xero integration can push approved time entries to Xero as draft invoice line items automatically. The integration creates the draft; you review and send. No manual line-item entry is required. The frequency of automatic pushes can be set to daily, weekly, or triggered before invoicing.
How do I handle multiple billing rates in a Xero time tracking integration?
Configure rate overrides per project or per client in your time tracking tool, then ensure those rates match the corresponding Xero invoice line items. For clients with different rate cards (e.g., junior vs senior developer rates), use separate time entry categories that map to separate Xero line item types. Most tools support rate tiers; the key is that the time tool and Xero agree on the rate for each billable category.
Does the time tracking to Xero sync work in real-time?
It depends on the integration. Native integrations like Harvest and Keito can sync on a scheduled basis (daily or weekly) or on-demand when you trigger billing. Zapier-based setups like Toggl Track can fire in near-real-time when a time entry is marked billable. For most billing workflows, on-demand or daily scheduled sync is sufficient — real-time sync is most useful when you want Xero drafts continuously updated for review.
How do I track non-billable time without it appearing on Xero invoices?
Mark time entries as non-billable in your time tracking tool. A properly configured Xero integration only syncs entries with the “billable” flag set. Internal meetings, team admin, and overhead time should be marked non-billable at entry time. You can also configure default billing rules per project — for example, a project type of “internal” that defaults all entries to non-billable regardless of the developer’s setting.