Skip to main content
Zapier is Flowyte’s universal bridge to the thousands of apps that don’t have a built-in Flowyte connector. If your app is HubSpot, Jobber, Shopify, Google Sheets, or a SQL database, use its built-in connector instead — it’s faster and deeper. For everything else, Zapier lets your agent recognize your customers, take live actions during a call, and log calls back into your tools — all through your own Zapier account.
You pay Zapier for tasks; Flowyte doesn’t charge extra. Everything here runs on your Zapier plan at Zapier’s normal task pricing. Flowyte adds no fee for Zapier calls or for storing your synced records.
There are three things you can set up — do the one(s) you need:

Recognize callers

Sync your customers in so the agent greets them by name and looks them up instantly — no per-call cost. Start here.

Live actions on a call

Book an appointment or update a ticket mid-call through a Zapier MCP connection.

Call events out

Log the call or notify your team the moment a call ends.

​
Before you start

  • A Zapier account — any paid plan for real volume; the free plan is fine to test.
  • Your Flowyte account with at least one agent.
  • For the triggers/actions in sections 1 and 3, the Flowyte Zapier app. During the beta it’s invite-only — use the invite link your Flowyte contact sent you to add “Flowyte” to your Zapier account. (Once it’s public it’ll be in Zapier’s app directory.) Section 2 (live actions) needs no app — it uses your own MCP endpoint.

​
1. Recognize callers (sync your customers in)

This is the most valuable setup and costs the least. A Zap copies your customer records into Flowyte; the agent reads them locally at call time — instant, and no Zapier task per call.
1

Build the sync Zap

In Zapier, create a Zap. Trigger: your app (e.g. “New or Updated Contact” in your CRM). Action: Flowyte → Create or Update Record. Connect your Flowyte account when prompted.
2

Map the fields

Pick the record type (e.g. customer) and map your app’s fields onto it — at minimum a phone number (how the agent matches a caller) and a name. Add anything the agent should know (account status, last order, …). Turn the Zap on.
3

Backfill your existing customers — don't skip this

A fresh Flowyte store is empty, so until you load your existing records the agent recognizes nobody and looks broken. Load them once with Zapier Transfer (bulk-run your existing records through the same Create/Update Record action) or a CSV import into Flowyte.
How the agent uses it: on a call it matches the caller’s number and greets them by name. Sensitive details (balance, address, order history) are only read out after the caller verifies their identity — caller ID alone is spoofable, so Flowyte protects those fields by design. Leave the Zap on; if you turn it off, the agent works from stale data.

​
2. Take live actions during a call (Zapier MCP)

For things the agent must do live — “book me in now”, “update my open ticket”, “check today’s availability” — connect a Zapier MCP endpoint. Flowyte calls your Zapier action mid-call and waits for the result: a couple of seconds for a classic server’s direct action call, more like 10+ seconds for an agentic server (Zapier shapes the response with its own AI layer) — the agent covers the pause naturally either way. For a pure write that nothing needs to read back — logging the call, creating a lead, tagging a contact — you can send it in the background instead, so the caller isn’t kept waiting on it at all; see Send writes in the background below.

​
Set up your Zapier MCP server

1

Create the server and enable specific actions

At mcp.zapier.com, create an MCP server and enable the exact actions you want the agent to run (e.g. “Create Appointment”). See Zapier’s MCP docs for the current setup steps — their UI evolves. Any server works, including the dynamic-discovery (“agentic”) servers Zapier now creates by default — you pick the specific action in Flowyte next, and Flowyte resolves it into a concrete, pinnable schema.
2

Copy the endpoint and token

On the server’s Connect step, copy the endpoint URL (it contains a token). Keep it secret — it’s the credential Flowyte uses; rotating it in Zapier revokes Flowyte’s access.

​
Connect it in Flowyte, resolve the action, and freeze a skill

1

Connect the endpoint

In Flowyte, open Integrations → Zapier → Connect and paste your MCP endpoint URL. Flowyte lists the actions you equipped. (API: POST /integrations/zapier/connect, then GET /integrations/zapier/tools.)
2

Pick the action — Flowyte resolves it to a pinnable schema

Pick the specific action you want (e.g. “Create Spreadsheet Row”). Flowyte resolves it to a concrete, closed schema of typed fields — this works the same whether your server is classic or agentic; you never freeze a generic “run any action” tool.
3

Pin dynamic parents when prompted

Actions with dynamic fields (a spreadsheet’s columns, a CRM’s custom fields) only expose their concrete fields once their parent is pinned — the specific spreadsheet, then its worksheet, then its columns resolve. Flowyte prompts you to pin each parent in turn (spreadsheet → worksheet → column) — pick a value and it re-resolves the next level down. Leave a parent unpinned and its dynamic children can’t be frozen.
4

Probe the action (reads)

For a read action, Probe it — Flowyte runs it once against a real record so you can choose exactly which response fields the agent may read back (deny-by-default). Write actions skip live probing — Flowyte already knows their response shape.
Probing runs the real action — it may create or send something. Only probe an action you’re comfortable executing once.
5

Author Instructions and Output, then freeze

Write the Instructions (what the action should do) and the Output — the Output must ask for the result as strict JSON, since that’s what Flowyte parses to hand fields back to the agent. Then freeze the action into a skill. Every action is treated as a write by default: the agent confirms with the caller before running it and runs one at a time. If an action genuinely changes nothing, mark it a read — you’ll write a short reason, recorded for audit. If it’s a write the agent doesn’t need to hear the result of, turn on background sending (below) so the call doesn’t wait on it. Or let Flowyte Assist do the resolve-and-freeze for you — just describe what you want.

​
Send writes in the background

Not every write needs the agent to wait on it. If the action is a pure send — log the call in your CRM, create a lead, tag a contact, kick off a downstream Zap — nothing on the call reads its result back, so there’s no reason to hold the turn open for it. Turn on fireAndForget when you freeze that skill and:
  • the agent still confirms with the caller first, exactly as before — background sending only changes what happens after the caller says yes;
  • on the confirmed call, Flowyte hands the same pinned arguments to a background queue and tells the caller it’s done right away, instead of blocking the turn on the live Zapier call;
  • a background worker completes the real send moments later, off the call, with automatic retries and de-duplication (a retried confirmation is never sent twice);
  • if the send eventually fails, the caller was already told “done” and is gone by then — the failure surfaces to you, not them: it shows up as a failed step on the call’s Observe receipt and triggers an internal alert so you can follow up (reconnect, re-freeze, or resend manually in Zapier).
Only turn this on for actions where a later failure is genuinely fine to catch after the fact — not for anything the caller is relying on hearing confirmed in the moment. It’s write-only: Flowyte won’t apply it to anything marked or resolved as a read, since a read has nothing to send in the background. It’s off by default; set "fireAndForget": true per skill when you freeze it. Full field reference: Zapier connector reference.
Cost: each live action is about 2 Zapier tasks on your plan, whether it runs live or in the background — background sending changes only when the action runs, not what it costs. Use live actions (with or without background sending) for things that must happen on the call; use the records sync (section 1) for anything you can only look up.

​
3. Send call events to your apps

Log calls or notify your team automatically when a call finishes.
1

Create a Zap with the Flowyte trigger

Choose an event: Call completed (fires when the call ends — caller, duration, outcome), Call analyzed (a few minutes later — outcome, sentiment, and a summary), or Call transferred.
2

Write it wherever you like

A CRM note, a Slack message, a spreadsheet row. Turn the Zap on.
Privacy: these events include the caller’s phone number, and “Call analyzed” includes a call summary — personal data. Send it only to apps and people who should see it.

​
Which Zapier plan do I need?

Everything runs on your Zapier plan, billed in tasks. The driver is usually the live actions: 
Monthly live-action tasks  ≈  (calls/month) × (live actions/call) × 2
Example: 1,000 calls/month with ~1 live action each → ~2,000 tasks/month for live actions; add your record syncs (~1 task each) and call-log Zaps (~1 task per call) → pick a Zapier plan comfortably above your total. Prefer the records sync for lookups (no per-call task) and reserve live actions for what must happen on the call. Zapier’s tiers change — check zapier.com/pricing.

​
Troubleshooting

Did you backfill? A new store is empty until you load existing customers (Zapier Transfer or CSV). Is the sync Zap on? Check “last synced” in Flowyte — if it’s old, the Zap is off or out of tasks. It greets by name but won’t read a balance/address → by design: sensitive fields need the caller to verify first.
Pin its parent first — the specific spreadsheet, then its worksheet — and re-resolve the action; its columns/fields materialize once the value above them is pinned.
The integration card shows a degraded/down reason: out of tasks (your Zapier plan ran out — the agent says a graceful line; upgrade Zapier), needs reconnect (your MCP token rotated — reconnect with the fresh URL), or timed out (usually transient). Bulk/“send to everyone” actions are blocked on purpose — pin the exact recipient in Zapier.
If you rebuilt the Zap, relink from the new one. If it “just stopped,” your catch URL was failing and Flowyte disabled it after retries — fix the Zap and re-enable it in Flowyte. If Flowyte shows the event delivered but nothing happened, check the Zap’s history in Zapier.
The caller already heard “done,” so Flowyte doesn’t call them back to say otherwise. Check the call’s Observe receipt for a failed step, and look for the internal alert email — both name the skill and the reason. Common causes: your Zapier token rotated (reconnect), the account ran out of tasks, or (for a dynamic-field action) its columns changed shape since you froze it — re-freeze after a column change. The write is never silently retried into a second execution; a failed send stays failed until you act.

​
Safety model

  • Scoped access — Flowyte only sees the actions you equipped on your server. Your token is the credential; revoke it in Zapier and access ends.
  • Frozen skills — a skill pins its arguments, allow-lists exactly which output fields the agent may read (deny-by-default), and treats every action as a confirm-gated write unless a human attests it’s read-only.
  • Background sending never skips the confirm gate — fireAndForget only changes what happens after the caller says yes to a write; it still confirms first, and a send that ultimately fails is always reported to you (Observe + an internal alert), never silently dropped.
  • Your bill, your data — Zapier calls run on your Zapier plan; Flowyte adds no markup.
See the Zapier connector reference for the full endpoint list.