Skip to main content
Zapier is the universal fallback connector. When Flowyte doesn’t have a native connector for an app, you connect your Zapier MCP endpoint and the agent can use any action you’ve equipped there — 8,000+ apps, live on a call. Each equipped tool is frozen into an mcp skill: you choose exactly which inputs the agent fills and which fields it may read back. 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.
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 tool once to learn which fields it returns, so you can choose what the agent may read.
5

Freeze a tool into a skill

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

​
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). 
curl -X POST https://builder.flowyte.com/api/v1/integrations/zapier/connect \
  -H "Authorization: Bearer flowyte_sk_…" -H "Content-Type: application/json" \
  -d '{ "credentials": { "endpoint": "https://mcp.zapier.com/api/mcp/s/…/mcp" } }'
# → { "data": { "status": "connected", "toolCount": 12 } }

​
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: 
curl https://builder.flowyte.com/api/v1/integrations/zapier/tools \
  -H "Authorization: Bearer flowyte_sk_…"
# → { "data": { "serverMode": "classic", "tools": [ { "name": "…", "inputSchema": { … } } ] } }
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.
curl -X POST "https://builder.flowyte.com/api/v1/integrations/zapier/tools/find_contact/probe" \
  -H "Authorization: Bearer flowyte_sk_…" -H "Content-Type: application/json" \
  -d '{ "acknowledge_execution": true, "args": { "email": "sam@example.com" } }'
# → { "data": { "leaves": [ { "path": "contact.name", "sample": "Sam Rivera", "pii": "name" }, … ] } }

​
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; allowedFields (dotted leaf paths from the probe) is deny-by-default. Because an MCP tool carries no read/write metadata the skill lands fail-closed as a write (confirm + non-parallel) unless readAttestation.attestedRead is true — a human downgrade recorded verbatim for audit. Bulk/broadcast-shaped tools are refused. 
curl -X POST https://builder.flowyte.com/api/v1/agents/AGENT_ID/integrations/zapier/mcp-skills \
  -H "Authorization: Bearer flowyte_sk_…" -H "Content-Type: application/json" \
  -d '{
        "toolName": "find_contact",
        "skillName": "Look up the caller",
        "pinnedArgs": { "workspace": "acme" },
        "allowedFields": ["contact.name", "contact.status"],
        "readAttestation": { "attestedRead": true, "note": "read-only lookup, changes nothing" }
      }'
Don’t want to hand-author? Let Flowyte Assist do the probe-and-freeze — just describe the action you want.

​
In the API

ActionEndpointScope
Connect the MCP endpointPOST /integrations/zapier/connectintegrations:write
List equipped tools (serverMode)GET /integrations/zapier/toolsintegrations:read
Resolve an action to a pinnable schema (agentic servers)POST /integrations/{kind}/tools/{tool}/resolveintegrations:read
Probe a tool (executes it)POST /integrations/{kind}/tools/{tool}/probeintegrations:write
Freeze a tool into a skillPOST /agents/{agentId}/integrations/zapier/mcp-skillsskills:write
Subscribe to call eventsPOST /agents/{agentId}/integrations/zapier/triggerswebhooks:write
DisconnectDELETE /integrations/zapierintegrations:write
Freezing edits the draft. Publish so live callers get the new skill.
Full walkthrough: Connect Zapier.