Choose an integration SDK by deciding whose account is connected and who is allowed to act through it. If a customer connects Salesforce so your product can update it, begin with an embedded connection model. If an organization-owned agent uses approved company accounts, begin with an agent-tool model. If you need both, evaluate both paths and their identity boundaries before comparing catalog size.
For example, an agent might classify a support request and propose a CRM update. The SDK can provide authenticated access to the CRM, but your application still needs to verify the tenant, validate the proposed fields, decide whether approval is required, and record the result. This is a selection and design guide, not a promise that any vendor supplies a complete, vendor-neutral workflow.
The practical goal is to select the smallest integration surface that supports one verified operation, then add controls around identity, authorization, validation, execution, and recovery.
The short answer: choose by account ownership and execution model
Shortlist vendors by the exact operation you need. Then verify who authorizes the account, which identity executes the operation, what governance applies, whether the feature is available on your plan, and what production use costs. A large catalog does not prove that the specific app, action, trigger, endpoint, or OAuth scope you need is supported.
Write down one real operation before comparing vendors. Examples include reading a CRM contact and updating one permitted field, receiving a support-ticket event and creating a project task, or sending an approved Slack message. Confirm the app, operation, authentication scopes, account model, and production conditions in current documentation for Zapier, Nango, Composio, and Pipedream Connect. These products expose different primitives, not interchangeable implementations.
Separate embedded connections from agent-owned tools
An embedded connection lets a signed-in product user authorize an external account. Your product then acts within that connection and its granted permissions. An agent-owned connection is controlled by the developer or organization; an agent receives access only to the tools or accounts that organization makes available. A hybrid product needs an explicit mapping among its authenticated user, tenant, and the vendor’s user or connection identifier.
User authorizes, product acts
Validate the signed-in user and tenant before creating or using a vendor identity. Keep each connection associated with the correct application account and provide a reconnect or revoke path.
Organization controls, agent acts
Expose only organization-approved accounts and tools to the agent. Restrict the operation in application policy, not just in the agent’s prompt.
Zapier White Label documents embedded actions, triggers, workflows, and agent connections, and is currently in limited access. Pipedream Connect documents external-user identities and connected accounts. Nango and Composio also document user-scoped connection capabilities. In every model, an authorized connection does not by itself authorize every action your application offers.
Evaluate the operation, controls, and operating cost
Catalog figures describe different things. Apps, APIs, pre-built actions, tools, triggers, syncs, and connected accounts are not equivalent units. The figures and prices below are vendor-reported and were checked on November 17, 2026. They can change, and they do not establish that a particular operation or scope is available.
- Verify the exact surface: Is the operation a pre-built action, tool, trigger, sync, or raw API request? Confirm its required scopes and provider behavior.
- Check the control boundary: Determine whether governance applies to raw API calls as well as pre-built operations.
- Confirm deployment and eligibility: Check beta or limited-access status, enterprise opt-in, self-hosting or BYOC terms, and production user limits.
- Model actual billing: Identify whether charges depend on tasks, tool calls, external users, connections, compute, or another unit. Confirm what the plan includes.
Zapier’s current SDK documentation says its app and action governance applies to pre-built actions, while direct fetch-based API calls are not yet covered by those controls. If you use raw calls, define and enforce the needed policy in your application instead of assuming action controls cover them.
How the four options differ
These are conditional fits, not a universal ranking. Use each vendor’s current documentation to test the required operation and its production terms.
| Vendor | Potential fit | Documented distinction | Buying constraint to verify |
|---|---|---|---|
| Zapier SDK | Managed TypeScript actions and broad app access | 9,000+ app integrations and approximately 3,600 app APIs for raw authenticated access | Open beta and free until December 1, 2026, when task-based billing is scheduled to begin. Enterprise accounts are off by default and require manual opt-in. White Label is in limited access. |
| Nango | Teams that want to own integration functions within an integration layer | Developer-written or generated TypeScript functions; vendor advertises 1,000+ APIs and 7,000+ tools, triggers, and syncs | A $50/month pay-as-you-go plan is listed with usage limits. Self-hosting and BYOC are enterprise-dependent. |
| Composio | Agent teams whose framework and connection model match its SDK paths | Framework guides, managed authentication, per-user connections, and MCP sessions; official pages advertise more than 1,600 or 1,700 app toolkits | Hobby is free. Pro is listed at $29/month with usage limits. Catalog terminology and counts vary by page. |
| Pipedream Connect | Products needing embedded accounts and agent-oriented tools or API access | 3,000+ APIs and 10,000+ pre-built tools and triggers, plus MCP and proxy access | Development is free. Startup is listed at $99/month when billed monthly, subject to external-user and usage rules. |
For Zapier, distinguish the SDK from White Label: the SDK is in open beta, while White Label is in limited access and partner billing is task-based. For Nango, do not assume enterprise self-hosting or BYOC options are included in a standard plan. For Composio and Pipedream, check the limits that apply to tool calls, connected accounts, external users, and usage. Pricing, product access, and catalog counts are plan-specific and should be confirmed directly before commitment.
Design the execution path before giving an agent write access
Keep the application responsible for identity, authorization, validation, approval, and durable status. The vendor connection provides a way to reach an external service; it does not decide whether a user in your product may perform a particular business operation.
The following is a hypothetical application payload, not a vendor schema. It represents one requested operation. The model can propose the action and arguments, but the application must resolve the identity and decide whether execution is allowed.
{
"tenant_id": "tenant_42",
"app_user_id": "user_108",
"connection_id": "conn_73",
"request_id": "req_9f2",
"action_id": "slack.send_message",
"arguments": {
"channel_id": "C123",
"text": "The approved update"
}
}
Use simple rules instead of AI for tenant ownership, permissions, required fields, allowed status transitions, destination allowlists, and duplicate prevention. AI can interpret ambiguous requests, classify text, extract fields, or summarize evidence. Treat its output as a proposal until deterministic checks pass.
Three useful implementation patterns
The examples below are proposed application designs using documented vendor primitives. They are not complete workflows supplied or guaranteed by any one vendor.
| Trigger or source | AI job | Validation and action | Fallback owner |
|---|---|---|---|
| User-authorized action: signed-in user request, tenant, connection, and selected action | Interpret the request and propose structured arguments. Do not choose an unbounded destination. | Check connection ownership, action allowlist, fields, scopes, and approval policy. Execute server-side and save status. | Integration owner handles revoked access, provider errors, policy rejection, and approval requests. |
| Event sync: provider event or documented polling result, source ID, and connection | Usually none for event identity or deduplication. Optionally classify validated payload content. | Validate tenant and event, enforce a unique event grain in the database, then transactionally upsert the destination record. | Integration operations investigates invalid events, unmapped tenants, throttling, and retry exhaustion. |
| CRM write-back: changed record text, source ID, tenant, and source version | Classify ambiguous language and extract evidence-backed fields. | Validate output, re-read the CRM record, check for human edits and allowed transitions, then write approved fields and a separate decision record. | CRM or business-process owner reviews low-confidence results, conflicts, and sensitive cases. |
Example 1: bounded agent action
A model might propose the following output after a user asks for a channel update. The application, not the model, determines approval and validates the arguments against the selected action schema.
{
"action_id": "slack.send_message",
"arguments": {
"channel_id": "C123",
"text": "The approved update"
},
"reason": "The user requested this channel update"
}
Reject the proposal if the channel is outside the tenant’s allowlist, the selected connection belongs to another user, required fields fail validation, or the action is not permitted by policy. For externally visible messages, require approval before execution and store the request ID, connection ID, result, and reviewer decision.
Example 2: deduplicated event synchronization
Define what one stored row represents before writing the consumer. In this example, the row grain is one provider event for one tenant and connection. A provider event ID is preferable when its uniqueness semantics are documented. Otherwise, define a composite key that reflects the event grain.
{
"tenant_id": "tenant_42",
"connection_id": "conn_73",
"provider_event_id": "evt_829",
"entity_type": "contact",
"external_record_id": "contact_551",
"source_updated_at": "2026-11-17T10:30:00Z",
"processing_status": "pending"
}
This sample is an illustrative application record, not a vendor-published schema. If the provider does not guarantee a unique event ID, a proposed key could be tenant_id + provider + connection_id + entity_type + external_record_id + source_updated_at. Document why that key represents one event observation, then enforce it with a database unique constraint and transactional upsert. A lookup followed by create is not race-safe when workers run concurrently.
Keep event-level records separate from aggregate reporting. Multiple deliveries of one event must not inflate business counts. Preserve a replay-safe event record or appropriately redacted representation, subject to retention and privacy requirements.
Example 3: AI classification with controlled CRM write-back
For a changed CRM or support record, let AI classify ambiguous text and extract evidence-backed fields. Do not let it decide tenant ownership, permissions, exact status transitions, or whether a write is allowed.
{
"tenant_id": "tenant_42",
"source_connection_id": "conn_73",
"source_entity_id": "record_551",
"source_updated_at": "2026-11-17T10:30:00Z",
"category": "billing_question",
"urgency": "normal",
"confidence": 0.86,
"evidence_spans": [
"The invoice total differs from the agreed quote"
],
"model": "classification-model",
"prompt_version": "triage_v3"
}
The row grain here is one classification run for one source record version, tenant, model, and prompt version. If you run two model variants against the same source, retain separate run records or include the model identity in the uniqueness rule. A separate decision record should link the source record, classification run, approval, destination record, and write result.
Validate the category against an allowed list, require evidence, and route low-confidence or unsupported results for review. Before writing, re-read the destination and compare its current version with the version used for classification. Do not overwrite a human edit. A CRM process owner handles conflicts or sensitive cases; see ConsultEvo’s CRM systems service for context on aligning integrations with business rules.
Production-readiness checks that affect the choice
Vendor-managed authentication and retries can reduce integration plumbing, but they do not remove your responsibilities for authorization, tenant mapping, destination validation, business-level idempotency, and exception ownership. Test these paths with the actual app operation and account model you intend to use.
- The exact operation, required scopes, and account-ownership model are verified.
- Every vendor user, tenant, and connection maps to an authenticated application identity.
- Beta, limited-access, opt-in, production-user, and plan conditions are understood.
- Production pricing and the relevant billing unit fit expected usage.
- Duplicate and retry behavior is defined with a database uniqueness rule where concurrent workers are possible.
- A named owner can resolve expired access, provider errors, and human-review cases.
Exercise expired and revoked authorization, rate limits, malformed arguments, duplicate delivery, retry exhaustion, and a destination edited by a person during processing. Track successful authorized operations, duplicate-write rate, exception resolution time, and manual-review volume. These are pilot measures, not performance results implied by a vendor.
Choose the smallest integration surface that meets the real need
First identify whose account is connected. Then test one required operation, choose only the surfaces that workflow needs, and compare governance, deployment, and production economics. A hybrid is reasonable when customers authorize accounts but an agent also needs background or event-driven work. Add each surface only for a defined use case.
For a bounded pilot, shortlist vendors against one real operation and include both an exception test and a duplicate or retry test. Teams defining an agent’s permitted job and operating controls can explore AI agent design and implementation. The right SDK is the one whose verified operation, identity model, controls, and commercial terms fit that workflow.
