> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowyte.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Zapier

> Bridge 8,000+ apps through your Zapier MCP endpoint — when no native connector exists, the agent reads and writes them live on a call.

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](/concepts/skills):
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.

<Note>
  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.
</Note>

## How it works

<Steps>
  <Step title="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.
  </Step>

  <Step title="List the equipped tools">
    Read the tools you've equipped — plus whether it's a `classic` or `agentic` server.
  </Step>

  <Step title="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.
  </Step>

  <Step title="Probe a tool (optional)">
    Run a tool once to learn which fields it returns, so you can choose what the agent may read.
  </Step>

  <Step title="Freeze a tool into a skill">
    Pin the constant arguments, expose the ones the agent fills, and allow-list the fields it reads.
  </Step>
</Steps>

## 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).

```bash theme={null}
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`**:

```bash theme={null}
curl https://builder.flowyte.com/api/v1/integrations/zapier/tools \
  -H "Authorization: Bearer flowyte_sk_…"
# → { "data": { "serverMode": "classic", "tools": [ { "name": "…", "inputSchema": { … } } ] } }
```

<Note>
  **`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](/guides/connect-zapier).
</Note>

## 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.

<Warning>
  Probing **runs the real action** — it may create, send, or book something.
</Warning>

```bash theme={null}
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.

```bash theme={null}
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" }
      }'
```

<Tip>
  Don't want to hand-author? Let **Flowyte Assist** do the probe-and-freeze — just describe the action
  you want.
</Tip>

## In the API

| Action                                                   | Endpoint                                                | Scope                |
| -------------------------------------------------------- | ------------------------------------------------------- | -------------------- |
| Connect the MCP endpoint                                 | `POST /integrations/zapier/connect`                     | `integrations:write` |
| List equipped tools (`serverMode`)                       | `GET /integrations/zapier/tools`                        | `integrations:read`  |
| Resolve an action to a pinnable schema (agentic servers) | `POST /integrations/{kind}/tools/{tool}/resolve`        | `integrations:read`  |
| Probe a tool (executes it)                               | `POST /integrations/{kind}/tools/{tool}/probe`          | `integrations:write` |
| Freeze a tool into a skill                               | `POST /agents/{agentId}/integrations/zapier/mcp-skills` | `skills:write`       |
| Subscribe to call events                                 | `POST /agents/{agentId}/integrations/zapier/triggers`   | `webhooks:write`     |
| Disconnect                                               | `DELETE /integrations/zapier`                           | `integrations:write` |

<Warning>
  Freezing edits the **draft**. [Publish](/concepts/agents) so live callers get the new skill.
</Warning>

Full walkthrough: [Connect Zapier](/guides/connect-zapier).