Connect Ayron to the rest of your business with Zapier and webhooks

Your business doesn't live in one app. The timer is here. The client roster is in a CRM. Revenue lands in a Slack channel because that's where the team sees it. The bookkeeper wants a row in a Google Sheet. The monthly review happens in Notion.

None of this is wrong. It's how real businesses run. The problem is the wiring: every time something happens in your time tracker, a person has to retype it somewhere else. That's the work this post is about removing.

Ayron emits events the moment they happen — a timer starts, a timer stops, an invoice gets paid — and Zapier (or Make, or n8n, or your own endpoint) takes those events and fans them out into whatever apps your team already pays for. The result: the timer is the source of truth, and every other tool stays in sync on its own.

This is a playbook, not a click-by-click Zap tutorial. Zap UIs change. The shape of the workflows does not.

The three events Ayron sends

Everything in this post is built on top of three events. They're sent as a JSON POST to whatever URL you configure under Settings → Integrations, with a signed x-ayron-webhook-secret header so the receiver can verify the request actually came from Ayron.

Every payload includes the workspace ID, the event name, a timestamp, and the row that triggered it. That row carries the IDs you need to enrich — project, client, task, amount — inside Zapier's lookup steps.

That's the whole reference. The rest of the post is what to do with it.

Playbook 1 — The studio owner: paid invoices that announce themselves

The moment a client pays, three things should happen automatically. They almost never do.

Trigger: invoice.paid

Workflow:

1. Post to a private #revenue Slack channel: amount, client name, project. The team sees momentum without anyone having to share it.
2. Append a row to a Google Sheet revenue ledger. Date, amount, client, invoice number. The bookkeeper now has the audit trail without asking.
3. Send a templated thank-you email from your domain. Short, human, and on time — which is the part that matters.

What used to be a 10-minute end-of-week ritual is now zero minutes and happens the instant Stripe clears the payment. The Slack notification alone is worth the wiring; it changes how a small team feels about its own pipeline.

Playbook 2 — The solo freelancer: a daily log that writes itself

If you do a weekly review on Sunday, the hardest part is reconstructing what happened on Tuesday.

Trigger: time_entry.stopped

Workflow:

1. Filter to billable sessions only.
2. Append a row to a Notion database — date, project, hours, the note you wrote when you stopped the timer.
3. At week's end, the same database is your raw material for client updates, an invoice reconciliation, and the next week's plan.

The point isn't that Notion is the right destination. The point is that the moment of stopping the timer is the moment your memory is sharpest, and that's the moment to capture context. Anything later is reconstruction.

Playbook 3 — Bookkeeping: paid invoices that show up in QuickBooks on their own

For studios already running QuickBooks or Xero, the monthly book-keeping ritual is mostly data entry that should have been automatic.

Trigger: invoice.paid

Workflow:

1. Create a sales receipt in QuickBooks Online (or Xero) for the paid invoice.
2. Map client and project to your existing customer record. Zapier's lookup steps handle the ID translation.
3. Attach the invoice number so reconciliation is one-click.

End of month becomes a review instead of a re-entry. If you have a bookkeeper, they thank you. If you don't, you got the hour back.

Playbook 4 — The team lead: a gentle nudge when a timer runs too long

Tracked time is only useful when it reflects what actually happened. A timer left running over lunch — or overnight — corrupts the data and the invoice that comes from it.

Trigger: time_entry.started, with a Zapier delay step

Workflow:

1. Wait 4 hours.
2. Check whether the timer is still running (a quick read against Ayron's data via a follow-up step, or by keying off the matching time_entry.stopped event).
3. If it's still going, send a Slack DM to the teammate: "Heads up — your timer on Client A · Discovery is at 4h. Still tracking?"

You don't get angry over-tracked timesheets. You get a small, polite catch before the bad data ever exists.

Playbook 5 — Client reporting: a weekly digest doc, generated on its own

Most freelancers under-report progress. Not because they didn't do the work — because writing the update on Friday feels like more work after the work.

Trigger: time_entry.stopped, filtered to one client's project

Workflow:

1. Each stopped session appends to a Google Doc keyed to that client's name and the current week.
2. Friday morning, the doc already lists every session, every note, and the running hour total.
3. You spend 10 minutes shaping it into a client update instead of 60 minutes reconstructing it.

A version of this loop with a Notion page works identically. Use whatever your client already reads.

Playbook 6 — CRM-side: mark the deal won the instant the invoice clears

If your CRM is the place you forecast revenue, the moment a deal becomes real revenue should be reflected there — not at the next pipeline review.

Trigger: invoice.paid

Workflow:

1. Look up the contact in HubSpot or Pipedrive by client email.
2. Move the associated deal to "Closed Won."
3. Log the payment as a CRM activity, so future-you sees the timeline cleanly.

The forecast stays honest, and you stop needing a Friday pipeline-hygiene meeting.

Playbook 7 — Personal analytics: an Airtable for weekly reviews

This is a quieter use case, but it compounds. If every stopped session lands in an Airtable, six months from now you have a dataset that tells you things your memory can't: which project actually paid per hour, what time of day you do your best work, how often a "quick task" became a 3-hour rabbit hole.

Trigger: time_entry.stopped

Workflow:

1. Append a row to Airtable with project, client, hours, billable flag, hourly rate, note.
2. Build a weekly review view that surfaces the largest sessions, the longest projects, and the most off-estimate work.
3. Use it as the input for your Sunday planning.

You already have all this data inside Ayron's reports. The reason to fan it out is that some people review weeks better in their own spreadsheet, with their own columns. The webhook lets you keep your habit instead of changing it.

When Zapier isn't the right tool: raw webhooks

Zapier is the right starting point because it handles auth, retries, and a thousand pre-built app integrations you'd otherwise wire by hand. But it isn't the only option, and for a few cases it's the wrong one:

• Make or n8n — visual automation tools with cheaper unit economics at high event volume, and richer branching logic. Both accept the same webhook payload Ayron sends to Zapier.
• An internal endpoint — if you have a backend service that already handles the business logic (a custom CRM, an internal billing portal, a Discord bot), point the webhook straight at it. Verify the x-ayron-webhook-secret header on receipt and you have an authenticated event stream with no third party in the middle.
• A Cloudflare Worker or AWS Lambda — for fan-out logic that's easier to write as code than to draw as a Zap. Cheap, fast, and entirely yours.

The "Raw webhooks" panel in Settings → Integrations is the lane for all of these. The payload shape is identical to the Zapier one, and the signing header is the same.

Related integrations: Asana, Linear

If Asana or Linear is the place your work actually originates, the dedicated integrations turn those task hierarchies into one-click timers — no Zap required. They pair well with the webhooks above: start the timer from your Asana task, and let time_entry.stopped fan out to wherever your business needs to know about it.

• Time tracking for Asana, without leaving Asana's hierarchy
• Time tracking for Linear, without context-switching out of an issue

What's coming

The three events above cover the moments most workflows care about. We're also working on a richer read API so you can pull data on demand rather than only reacting to events — weekly time totals, invoice histories, raw monthly report data. Per-scope tokens will let you grant a Zap or an internal tool exactly the access it needs, no more.

If you have a workflow you'd want to build the moment that's available, send it to us. The API surface will be shaped by what people actually want to integrate, not by guessing.

How to set this up

1. Open Settings → Integrations in Ayron.
2. In Zapier, create a new Zap with Webhooks by Zapier → Catch Hook. Copy the URL Zapier gives you.
3. Paste it into the Zapier webhook URL field, pick the events you want, and save.
4. Trigger one of those events in Ayron (start and stop a timer, or mark a test invoice paid). Zapier receives the payload and you can map fields into the destination app.
5. Repeat for each workflow above — one Zap per use case is fine, and easier to debug than one mega-Zap.

Every webhook can be paused or deleted from the same screen. Each delivery is logged, so when something doesn't fire, you can see why.

The wiring is small. The compounding is large. A week from now, three things you used to do by hand are happening on their own, and you didn't have to change a single habit to get there.