Skip to main content
Zapier is the universal fallback connector for write actions. When Flowyte doesn’t have a native connector for an app, you connect your Zapier MCP endpoint and the agent can take a live action on a call — book an appointment, update a ticket, log the call, notify your team — across the 8,000+ apps Zapier supports. Each equipped tool is frozen into an mcp skill: you choose exactly which inputs the agent fills. Unlike the curated providers, Zapier ships no pre-built actions — every customer’s server exposes a different set, so the “pack” is the discover-and-freeze flow itself.
To recognize callers or read their data, don’t read live through Zapier — sync records into Flowyte instead. A live Zapier action takes 10–13 seconds, too slow to block a call while the agent waits for a lookup. Instead, sync your records into Flowyte’s caller-context store (the Zapier Create or Update Record action, or the Records API) and the agent reads them locally in under 100 ms — no Zapier call, no per-call task cost. See Recognize callers. Reserve live Zapier calls for writes.
Authenticate every request with a secret API key: Authorization: Bearer flowyte_sk_…. The kind is zapier. You pay Zapier’s task pricing on your own plan; Flowyte adds no markup.

​
How it works

1

Connect your Zapier MCP endpoint

Paste the MCP server URL from your Zapier account — no OAuth. Flowyte runs initialize + tools/list and reports how many actions are equipped.
2

List the equipped tools

Read the tools you’ve equipped — plus whether it’s a classic or agentic server.
3

Resolve the action (agentic servers)

Pick the specific action; Flowyte resolves it to a concrete, closed schema, pinning any dynamic parents (spreadsheet → worksheet → column) along the way. Classic servers already expose a closed schema per tool, so this step is a no-op for them.
4

Probe a tool (optional)

Run a write once to see what it returns, so you can pick what the agent reads back (skip it for fire-and-forget sends that don’t read anything).
5

Freeze a tool into a skill

Pin the constant arguments, expose the ones the agent fills, and allow-list any fields it reads back.

​
1. Connect

Zapier connects with an API-key-style credential: paste your Zapier MCP server endpoint URL (the secret is embedded in the URL). It’s encrypted at rest and never echoed back. The toolCount in the response is how many actions are equipped — the connect wizard shows it (or a designed empty state at 0).

​
2. List the equipped tools

GET /integrations/zapier/tools runs tools/list against your endpoint and returns each equipped tool’s name, description, and raw JSON-Schema inputSchema — the discovery step for authoring a skill. The envelope also carries serverMode:
serverMode: "agentic" means your server exposes a few generic executor tools (execute_zapier_read_action, …) instead of one tool per action — and that’s fully supported. Pick the specific action you want; Flowyte calls POST /integrations/zapier/tools/{tool}/resolve to resolve it to a concrete, closed, pinnable schema (materializing dynamic fields once their parents are pinned), then you freeze it exactly like a classic tool. See Connect Zapier.

​
3. Probe a tool (optional)

An MCP tool has no output schema and Zapier has no sandbox, so to learn which fields a tool returns you run it once and inspect the response. POST /integrations/{kind}/tools/{tool}/probe executes the real action with your args — you must set acknowledge_execution: true — and returns the response flattened to dotted leaf paths (with a name-based PII class per leaf) to allow-list at freeze time.
Probing runs the real action — it may create, send, or book something.

​
4. Freeze a tool into a skill

POST /agents/{agentId}/integrations/zapier/mcp-skills turns one equipped tool into a skill. Only the operator-exposed params become the skill’s parameters; pinned args are locked on at runtime. Every schema-required input must be pinned or exposed; any allowedFields the agent reads back (dotted leaf paths from the probe) are deny-by-default. Because an MCP tool carries no read/write metadata the skill lands fail-closed as a write — it confirms with the caller and runs one at a time — which is exactly right for the write actions Zapier is for. Bulk/broadcast-shaped tools are refused.

​
Send a write in the background (fireAndForget)

Some write actions are pure sends — log the call, create a lead, add a note, tag a contact, fire a downstream Zap — where nothing on the call reads the result back. Zapier’s action executor isn’t fast (an agentic server’s execute_zapier_write_action commonly takes 10+ seconds), so blocking a live turn on one wastes time the caller can feel. Add "fireAndForget": true to the freeze request for a write action and:
  1. the agent still confirms with the caller first — fireAndForget never touches the confirm gate, it only changes what happens after the caller says yes;
  2. on the confirmed call, Flowyte hands the exact same pinned + validated arguments to a durable background queue and tells the caller it’s done immediately, instead of blocking the turn on the live Zapier call;
  3. a background worker completes the real send off-turn, with automatic retries and de-duplication (a retried confirmation is never sent twice);
  4. if the send ultimately fails, the caller is not told — they’re already gone. The failure shows up as a failed step on the call’s Observe receipt and fires an internal alert, so an operator can follow up.
fireAndForget fits a write that sends and forgets — nothing on the call reads the result. Leave it off — the default — for a write whose result the agent reads back to the caller. To read caller data, use the caller-context store, not a live Zapier call.
Don’t want to hand-author? Let Flowyte Assist do the probe-and-freeze — just describe the action you want.

​
In the API

Freezing edits the draft. Publish so live callers get the new skill.
Full walkthrough: Connect Zapier.