Choose Zapier MCP for a small number of interactive calls from a compatible AI client, the Zapier SDK for repeatable TypeScript workflows that need application logic, and the Zapier CLI for discovering and testing actions from a terminal. The right choice depends on who owns the sequence and its controls, not on a universal record-count threshold.
For example, asking an AI client to retrieve project updates and prepare an email draft is a reasonable MCP use case. Processing CRM records against fixed eligibility rules is usually better owned by application code. Exploring whether an action exists before building either workflow is a CLI task.
These are execution surfaces over Zapier-connected apps, not three separate app catalogs. A project can use more than one, but each surface gives a different operator control over discovery, sequencing, validation, and writes.
The short answer: choose by how the work runs
| Surface | Best fit | Who owns the sequence | Main trade-off |
|---|---|---|---|
| MCP | Interactive, conversational actions using enabled tools | The compatible AI client and its user | Each successful tool call uses two tasks |
| SDK | Reusable TypeScript workflows with branching and state | Your application | You own validation, retries, state, and exceptions |
| CLI | Action discovery, prototypes, and terminal tests | The shell script or developer | Durable workflow controls need another layer |
Choose the surface that matches who owns the sequence: the AI client for interactive calls, application code for repeatable logic, or the shell for discovery and testing.
Zapier pages publish different app and action totals, and those figures change over time. Treat catalog counts as date-sensitive product descriptions, not technical limits. Start with the work, the data grain, and the controls it needs.
Zapier MCP: interactive tool calls with a reviewable boundary
Zapier MCP is Zapier’s hosted connection for compatible AI clients to discover and call tools representing actions in connected apps. The current MCP quickstart requires a client that supports Model Context Protocol over Streamable HTTP. Zapier MCP does not support SSE. Client configuration, account state, or administrator approval may also affect access.
One tool call represents an individual app action, but the client can orchestrate multiple calls in sequence. That makes MCP useful when a person wants to request a bounded task, inspect the result, and decide what happens next. A compatible client could retrieve recent project updates and prepare a draft for review. The conversational request should not be treated as automatic permission to send, publish, delete, or change a record.
Zapier’s published project-status example describes reading Coda rows updated during the week, summarizing progress, and creating an Outlook draft for review. The page confirms a draft, not automatic sending. It does not define a complete schema, duplicate strategy, provenance store, or exception workflow, so those controls must be designed separately if the pattern becomes operational.
Task use matters when calls repeat. Current MCP usage documentation says each successful MCP tool call uses two tasks and failed calls do not count. Count expected calls before using MCP for record-by-record work.
Zapier SDK: code-owned flow, schemas, and application logic
The Zapier SDK is a TypeScript package for discovering and executing actions within a Node.js project. Its documented capabilities include discovering apps, actions, input schemas, and connections; executing actions; and making authenticated fetch requests. The current SDK quickstart requires Node.js 20 or newer.
The quickstart describes OAuth, client credentials, and direct-token options. Local development can use CLI authentication, while client credentials are recommended for server-side deployments. Developers still need to protect local authentication state, client secrets, direct tokens, and connection-token URLs.
Choose the SDK when the application must own the sequence: process records, apply deterministic eligibility rules, retain per-record results, and route selected failures for review. Code can manage loops, intermediate state, branches, and error handling. This is a control-model choice, not a promise of faster execution. Test the actual workload and target app.
Action schemas describe fields and help shape requests, but they do not replace business validation. Your application still needs to decide whether a record is eligible, whether its data is current, and whether a proposed write is allowed. Zapier advertises raw authenticated API access for 3,000+ supported apps, but a valid endpoint, connection, account permission, and target-app behavior are still required. Do not assume every endpoint is available for every app.
Zapier also publishes @zapier/zapier-sdk-mcp, a separate package that can expose SDK functions as MCP tools. It is not the hosted Zapier MCP service. The package is in the 0.x open-beta family and documents stability tiers, so check its current status and expose only the tools needed by the client before using it on a production path.
Zapier CLI: discover and test actions before building
The SDK CLI provides terminal commands for app and connection discovery, action listing, input-field inspection, action execution, and authenticated HTTP requests. Current SDK CLI instructions use npx zapier-sdk. For example, this command lists Slack actions in machine-readable form:
npx zapier-sdk list-actions slack --json
The CLI reference documents the command syntax. The CLI walkthrough shows a broader sequence: find the app, inspect connections, list actions, inspect fields, resolve dynamic inputs, execute an action, and make an authenticated request where the target API and connection support it. Replace example IDs and values with those from your own account.
Some fields are dynamic and depend on context, such as the spreadsheet or worksheet selected. Treat the CLI output as discovery evidence, not as proof that a connection has the required downstream permission or that an endpoint behaves the same way across apps.
A practical selection test: compare the work, not just the tools
| Trigger and work shape | AI job | Validation and action | Fallback owner |
|---|---|---|---|
| One conversational lookup or draft | Retrieve context and summarize or prepare a proposed response | User reviews the result and any consequential write before execution | Requesting user or record owner |
| Repeated record processing | Interpret free text only where fixed rules are insufficient | Application validates each record, applies an idempotency strategy, and records the write outcome | Application owner or operations queue |
| Exploration or proof of concept | Optional help interpreting discovery output | Developer inspects fields, tests a read, and approves a controlled write | Developer |
For fixed conditions, use rules: a status equals “blocked,” a date falls inside a defined range, a required field is missing, or a destination ID is already present. Reserve AI for interpretation, such as summarizing free-text notes or mapping varied language to a controlled category. A structured result is useful when downstream code needs a decision, reason, source IDs, and a review flag rather than free-form prose.
Illustrative project-status design: read Coda updates for an explicit project and date window; ask AI only to summarize notes and map them to an allowed status; validate the result in code or have a reviewer check it; then create an Outlook draft for a project owner to review. The official template supports the Coda-to-Outlook draft pattern. The contract and validation below are proposed design choices, not documented behavior of that template.
{
"run_id": "run_2026-11-20_001",
"project_id": "proj_42",
"period_start": "2026-11-16",
"period_end": "2026-11-22",
"items": [
{
"source_record_id": "update_817",
"source_updated_at": "2026-11-20T09:15:00Z",
"decision": "in_progress",
"reason": "The note reports work underway, with no completion evidence."
}
],
"draft_key": "proj_42:2026-11-16:2026-11-22:run_2026-11-20_001",
"requires_human_review": true
}
Here the row grain is one source update. The run_id distinguishes repeated observations, while draft_key identifies this particular reported summary. Code checks that every item has a source record ID, each decision is one of complete, in_progress, blocked, or needs_review, and the requested date window is explicit. Missing or ambiguous status becomes needs_review. The project owner checks the Outlook draft before sending.
If concurrent runs can create drafts, do not rely on lookup followed by create as the only duplicate control. Use a database-enforced unique key at the intended draft grain, a transactional upsert, or a durable operation ledger. If the destination cannot provide those controls, serialize the write and reconcile failures.
MCP can orchestrate several actions, but each successful tool call consumes two tasks. Count calls per record, compare that pattern with an SDK loop or bulk read, and account separately for the target app’s limits and retry behavior.
Controls that matter across all three surfaces
Zapier provides connection and authentication infrastructure, but access still depends on the selected account, credentials, client configuration, organization policy, plan access, and target-app permissions. A connected account may still lack access to a specific record, folder, channel, or API scope.
For SDK and CLI raw requests, verify the endpoint, HTTP requirements, and connection. App-specific API behavior, rate limits, pagination, retries, and idempotency are not uniform. Input schemas describe action fields, while application-level business validation remains your responsibility.
For repeated processing, define the data grain before deciding what counts as a duplicate. Preserve a source record ID and run ID, and separate a raw observation from a reported summary or a CRM contact or deal event. A unique key should identify the declared operation at that grain. For example, a per-source-row update may use source_system + source_record_id + operation_type + version, while a weekly project draft may use project_id + period_start + period_end + output_type, with a run ID retained for provenance.
When concurrent workers can act on the same data, use a destination-supported unique key, transactional upsert, or database-enforced uniqueness. A durable operation ledger or serialized write can provide a fallback where the destination offers neither. Lookup followed by create alone is not race-safe.
Before a consequential write, use a consistent gate: confirm source identity and freshness; validate the destination and allowed values; check whether the operation already exists at the correct grain; execute the write; record the result or assign a named exception owner. Require a person to approve actions such as sending, deleting, or changing a lifecycle stage when their consequences warrant it.
- Confirm the connection, destination identity, and target-app permissions.
- Inspect required fields, dynamic fields, allowed values, and separate business rules.
- Declare the row or output grain and enforce uniqueness or upsert behavior at that grain.
- Preserve source IDs, run IDs, timestamps, and per-operation outcomes.
- Name an exception owner and define approval for sending, deleting, or other consequential actions.
Measure outcomes that match the job: successful reads and writes, validation failures, records escalated, duplicates prevented, review time, and task use when MCP calls repeat. These measurements help decide whether a conversational flow should remain interactive or move into application code.
Can MCP, SDK, and CLI work together?
Yes, when different stages or users benefit from different interfaces. A developer can use the CLI to inspect an action, build the repeatable process in the SDK, and offer hosted MCP separately for a user’s interactive task. An SDK-backed MCP server is another option through the separate adapter package, but it is not the hosted Zapier MCP service.
If you expose SDK functions as MCP tools, limit the exposed tools to the client’s actual task and review the adapter’s current stability tiers. Keep the application’s validation, identity, duplicate prevention, and approval controls outside the model’s discretion.
Do not install all three by default. Start with the simplest surface that meets the workflow’s control requirements: MCP for a bounded interactive task, SDK for a code-owned process, or CLI for discovery and testing.
If your team needs help selecting and implementing a controlled Zapier workflow, see Zapier automation consulting. For a bounded AI role inside a validated business process, explore AI agent implementation.
