DEV Community: Sapnesh Naik

How to sync large amounts of contacts from the HubSpot API

Sapnesh Naik — Thu, 07 May 2026 16:36:49 +0000

If you are building API integrations with HubSpot in your product, you will eventually need to sync more than 10,000 contacts from a customer's portal. That is not easy when you want a durable, resumable sync that fetches only new and changed records, instead of refetching everything on every run. You also need to think about managing the auth tokens for 100s of users, record storage, webhook updates, and more.

This guide walks through how to build a production-ready HubSpot contacts sync using Claude Code, Cursor, Codex, or any other AI Coding Agent with the Nango AI Function Builder skill.

The full working demo, including the Nango sync, an Express backend, and an HTML dashboard for browsing synced contacts, is on GitHub at NangoHQ/blog-demos/how-to-sync-large-amounts-of-contacts-from-hubspot-api.

Note: The same steps can also be used for syncing HubSpot companies, deals, tickets, and any other CRM Nango supports.

Why syncing large amounts of contacts from HubSpot is hard

HubSpot exposes contacts through two endpoints, and neither one is enough on its own:

Endpoint	Filter by `lastmodifieddate`?	10k total cap?
`GET /crm/v3/objects/contacts` (basic list)	No	No
`POST /crm/v3/objects/contacts/search`	Yes	Yes (400 error past 10k)

The search-the-crm guide confirms it: "The search endpoints are limited to 10,000 total results for any given query. Attempting to page beyond 10,000 will result in a 400 error." Search is also rate-limited to five requests per second per account.

So the search endpoint is the only one that filters by lastmodifieddate (what you need for incremental syncs), but it walls off at 10k. The basic list endpoint has no cap but no filter. The HubSpot community forum is full of 400 reports from developers who only used search and assumed their code was broken.

Solution to sync large amounts of contacts from HubSpot

Split the sync into two phases that share state via Nango checkpoints:

Initial phase. Page through every contact using the basic list endpoint. No 10k cap. After each page, save a checkpoint with the after cursor and the highest lastmodifieddate seen so far. Note: while this endpoint does have lastmodifieddate in its response, it does not support filtering by lastmodifieddate.
Incremental phase. Switch to the search endpoint. Filter by lastmodifieddate GT <watermark>, sort ascending by lastmodifieddate, and page through. Each page advances the watermark. If a request 400s past the 10k cap, catch the error, save the latest watermark, and start a fresh search from it inside the same run. Repeat until a search returns fewer than 10k results, so no modified records are missed.

Why building this from scratch is harder than it looks

The two-phase pattern is the easy part. The infrastructure underneath is the hard part:

Durable checkpoints that survive process restarts and store per-connection cursors and watermarks.
Resumable execution, so a 200k-contact backfill can stop and pick up across multiple runs without skipping or duplicating records.
HubSpot OAuth lifecycle with concurrent token refreshes and graceful handling of BAD_REFRESH_TOKEN.
Rate-limit handling with backoff and per-connection queuing for HubSpot's 5 req/s search cap.
Sync-completion webhooks so your backend knows when new records landed.

What Nango provides for building API integrations

Nango is an agentic API integrations platform. It gives you five building blocks that turn the two-phase pattern from a multi-week project into minutes of work with a coding agent:

Wide API support with managed auth. Pre-built auth for 700+ APIs, including HubSpot, with OAuth 2.0, API keys, basic auth, JWT, and other auth types. Token refresh, encryption, and revocation handling are managed for you.
AI Function Builder skill for coding agents. Install once with npx skills add NangoHQ/skills and your AI coding agent (Claude Code, Cursor, Codex, Gemini CLI, and others) gets the context to research the API, write a Nango sync or action in TypeScript, run dryruns against a real connection, and iterate until the integration works.
Actions and tool calls. Actions are functions written in TypeScript that run on Nango's infrastructure and are triggered from your app or by an AI agent. For example, a create-contact action calls POST /crm/v3/objects/contacts with the right token for the right connection, returning the created record.
Data syncs with record storage. Syncs run on Nango's serverless, tenant-isolated runtime. Synced records are stored in Nango's cache so your app can read them in a paginated manner with nango.listRecords(). The sync handles retries, rate limits, and resumable execution automatically.
Webhooks from external APIs. Nango ingests webhooks from external providers like HubSpot (for example, contact.deletion events), attributes each event to the right connection, and forwards a normalized payload to your backend. You write the handler once and Nango deals with provider-specific signing, retries, and routing.

Implementing a HubSpot contacts sync with Nango

Follow the steps below to implement a durable HubSpot contacts sync using the Nango AI Function Builder skill.

By the end of this section, you will have:

A customizable auth UI in your product so customers can connect their HubSpot account.
An initial backfill sync that fires the moment a new HubSpot connection is created and pulls all contacts.
An incremental phase that picks up only modified contacts on every run (every hour, customizable) and slides past the 10k search cap automatically.
Checkpoints that survive runtime restarts and rate limits.
A backend that receives sync-completion webhooks and reads only the records that changed.

Prerequisites

You will need a Nango account (the free tier is enough for development). Then register your own HubSpot OAuth app with the crm.objects.contacts.read scope, set the OAuth callback URL to https://api.nango.dev/oauth/callback, and configure HubSpot as an integration in the Nango dashboard.

Note: If you do not have your own HubSpot OAuth app yet, you can use Nango's pre-configured developer credentials to get going, then swap to your own credentials before going to production.

Next, install the Nango CLI and initialize an integrations project:

npm install -g nango
nango init
cd nango-integrations

Then install the AI Function Builder skill, so your coding agent has the context it needs to write Nango functions:

npx skills add NangoHQ/skills -s building-nango-functions-locally

This adds Nango's interface patterns, Zod schema conventions, dryrun testing flow, and CLI usage to whichever coding agent you use.

Tip: LLM training data on Nango is often stale. Add the Nango docs MCP server alongside the skill, so your agent can pull current API references during code generation.

Finally, set a Nango dev API key in a .env file at the root of nango-integrations so the CLI and dryrun commands can authenticate:

# nango-integrations/.env
NANGO_SECRET_KEY_DEV=<your-dev-api-key>

You can create or copy a dev API key from the Nango dashboard.

Step 1: Add a HubSpot test connection

Before generating the sync, create a real HubSpot connection in the Nango dashboard. The AI coding agent uses this connection to run nango dryrun against the live HubSpot API while it iterates on the function, so the generated code is tested against real responses.

In the Nango dashboard, click Add Test Connection, pick HubSpot, and complete the OAuth flow against a HubSpot developer account. Copy the connection ID from the connection details page; you will pass it into the prompt in the next step.

Step 2: Generate the contacts sync

Open your project in your AI coding agent and invoke the AI Function Builder skill with a prompt like the one below. Replace the connection ID with the one you just created.

Build a Nango sync for HubSpot contacts that runs every hour, handles
portals with more than 10,000 contacts reliably, and resumes cleanly
across runs without skipping or duplicating records.

Integration ID: hubspot
Connection ID: <your-connection-id>

Properties to sync: firstname, lastname, email, phone, jobtitle,
company, createdate, lastmodifieddate.

The agent figures out the rest from HubSpot's docs and the AI Function Builder skill: which endpoints to use, how to paginate, how to handle the 10k search cap, and how to checkpoint for resumability.

The agent researches both endpoints, writes the function, generates a test suite, runs nango dryrun against your test connection, and iterates on real responses until everything passes. Here is what the agent does behind the scenes.

Step 3: Review the generated sync

When the agent finishes, you will see three new files inside nango-integrations/hubspot/:

hubspot/syncs/fetch-contacts.ts: the sync function itself, with the two-phase logic, checkpoint schema, and Zod model.
hubspot/tests/fetch-contacts.test.json: a recorded HubSpot API response captured during the agent's dryrun, used as a deterministic fixture for unit tests.
hubspot/tests/hubspot-fetch-contacts.test.ts: the unit test that replays the fixture and asserts the sync produces the expected records.

Let's look at the important bits of the sync file. The full file with imports, schemas, helpers, and types is in the demo repo.

1. The createSync declaration and phase dispatcher. A string-only CheckpointSchema carries the phase, the basic-list cursor, and the watermark across runs.

const CheckpointSchema = z.object({
    phase: z.string(),
    after: z.string(),
    lastmodifieddate: z.string()
});

const sync = createSync({
    description: 'Two-phase HubSpot contacts sync that slides past the 10k search cap.',
    version: '1.0.0',
    frequency: 'every hour',
    autoStart: true,
    checkpoint: CheckpointSchema,
    models: { HubspotContact: HubspotContactSchema },
    exec: async (nango) => {
        const checkpoint = await nango.getCheckpoint();
        const phase = checkpoint?.phase === 'incremental' ? 'incremental' : 'initial';
        let watermark = checkpoint?.lastmodifieddate || undefined;

        if (phase === 'initial') {
            watermark = await runInitialPhase(nango, checkpoint?.after, watermark);
        }
        await runIncrementalPhase(nango, watermark);
    }
});

2. Initial phase: paginate through the basic list endpoint, save a checkpoint per page. No 10k cap on this endpoint, so a 200k-contact portal flows through across however many runs are needed.

const proxyConfig = {
    endpoint: '/crm/v3/objects/contacts',
    params: { limit: PAGE_LIMIT, properties: PROPERTIES.join(',') },
    paginate: {
        type: 'cursor' as const,
        cursor_name_in_request: 'after',
        cursor_path_in_response: 'paging.next.after',
        response_path: 'results',
        limit: PAGE_LIMIT,
        on_page: async ({ nextPageParam }) => {
            if (typeof nextPageParam === 'string' && nextPageParam) {
                await nango.saveCheckpoint({ phase: 'initial', after: nextPageParam, lastmodifieddate: watermark ?? '' });
            } else {
                // Backfill done. Switch to incremental on the next run.
                await nango.saveCheckpoint({ phase: 'incremental', after: '', lastmodifieddate: watermark ?? '' });
            }
        }
    },
    retries: 3
};

for await (const page of nango.paginate<HubspotContactRaw>(proxyConfig)) {
    const contacts = page.map(toContact);
    await nango.batchSave(contacts, 'HubspotContact');
    watermark = highestWatermark(contacts, watermark);
}

3. Incremental phase: search filtered by watermark, ascending, checkpointed per page. This is the part that solves the 10k cap. filterWatermark defines the search; savedWatermark advances per page. When a paged request 400s past the 10k cap, catch the error, restart the search from the latest watermark, and continue inside the same run until a slice returns fewer than 10k results.

let filterWatermark = savedWatermark;

while (true) {
    const filterGroups = [{
        filters: [{
            propertyName: 'lastmodifieddate',
            operator: 'GT',
            value: toMillisecondsString(filterWatermark)  // HubSpot wants Unix milliseconds
        }]
    }];

    let after: string | undefined;
    let hitTenKCap = false;

    while (true) {
        let response;
        try {
            response = await nango.post<SearchResponse>({
                endpoint: '/crm/v3/objects/contacts/search',
                data: {
                    filterGroups,
                    sorts: [{ propertyName: 'lastmodifieddate', direction: 'ASCENDING' }],
                    properties: [...PROPERTIES],
                    limit: PAGE_LIMIT,
                    ...(after ? { after } : {})
                },
                retries: 3
            });
        } catch (err) {
            // Past the 10k cap, HubSpot returns a 400. Restart the search
            // from the latest watermark inside the same run.
            if (isTenKCapError(err)) {
                hitTenKCap = true;
                break;
            }
            throw err;
        }

        const contacts = response.data.results.map(toContact);
        if (contacts.length === 0) return;

        await nango.batchSave(contacts, 'HubspotContact');
        savedWatermark = highestWatermark(contacts, savedWatermark);

        await nango.saveCheckpoint({ phase: 'incremental', after: '', lastmodifieddate: savedWatermark ?? '' });

        after = response.data.paging?.next?.after;
        if (!after) return;
    }

    if (!hitTenKCap) return;
    filterWatermark = savedWatermark;  // Slide the search window forward and loop.
}

A few design decisions worth calling out:

Checkpoints saved per page. The initial phase uses nango.paginate with an on_page callback; the incremental phase saves inline after each batchSave. Either way, if the function is interrupted, the next run resumes from the saved state rather than starting over.
Ascending sort on lastmodifieddate. Each search returns the lowest-watermark records first. When a request 400s past the 10k cap, the latest saved watermark is already past everything we just processed, so restarting the search from it picks up the next slice without gaps. The outer loop keeps sliding the window forward until a slice fits under 10k.
Milliseconds, not ISO, for the search filter. HubSpot's search endpoint expects lastmodifieddate as Unix milliseconds. toMillisecondsString handles the conversion.

Step 4: Deploy

Deploy just this sync to your Nango dev environment:

nango deploy --sync fetch-contacts dev

The sync now runs every hour for every connected HubSpot portal, starting with the initial backfill and automatically transitioning to the incremental phase once the backfill catches up.

Step 5: Handle sync-completion webhooks in your backend

When a sync run finishes with new records, Nango sends a sync-completion webhook to your backend with counts of added, updated, and deleted records, plus a modifiedAfter timestamp. Set the webhook URL in the Nango dashboard under Environment Settings > Webhooks. The demo app shows a working Express backend and an HTML dashboard that displays the synced contacts.

Then fetch only the records that changed:

const records = await nango.listRecords({
    providerConfigKey: 'hubspot',
    connectionId,
    model: 'HubspotContact',
    modifiedAfter: webhookPayload.modifiedAfter,
});

Tip: Always verify the webhook signature before processing using nango.verifyIncomingWebhookRequest(). Nango signs payloads with HMAC-SHA256, and verification requires the raw request body (before JSON parsing).

nango.listRecords is paginated. Loop through next_cursor until it returns null, so you do not silently drop records on portals with very high modification rates.

Local testing tip: To inspect webhooks during development, run ngrok against your local backend and set the ngrok URL as the webhook target in Nango's environment settings.

Step 6: Connect a new HubSpot account and test

With the sync deployed, connect a new HubSpot portal through Nango's auth UI. The sync starts immediately because of autoStart: true.

To verify the sync is doing the right thing:

Check the dashboard. The Nango dashboard shows per-run logs, record counts, current checkpoint, and durations. You should see an initial-phase run that each process all the contacts, then incremental runs that process only modified contacts.
Watch the checkpoint. During the initial phase, the checkpoint shows phase: "initial" with an advancing after cursor. Once the backfill completes, the phase flips to "incremental" and the lastmodifieddate watermark starts moving forward.
Modify a contact in HubSpot. Within the next hour, the incremental sync should pick it up, and your backend should receive a sync-completion webhook with addedOrUpdated: 1.

Edge cases worth knowing about

Custom properties. Update the prompt with the custom property names and rerun the AI Function Builder skill. For per-customer property lists, store them in connection metadata and read them during the sync.
Deletes. Search does not return deleted contacts. Subscribe to HubSpot's contact.deletion webhook. Nango can forward those webhooks to your backend after attributing each event to the right connection.

Conclusion

Syncing large amounts of contacts from HubSpot requires both of HubSpot's contact endpoints. Search filters by lastmodifieddate but caps at 10,000 results. The basic list endpoint has no cap but cannot filter. A reliable sync uses both, with checkpoints that resume cleanly across runs and durable infrastructure underneath: OAuth refresh, retries, rate limit handling, and webhook routing.

With Nango, the sync logic is a code function your AI coding agent generates from a prompt, while the infrastructure is managed for you. The same approach works for HubSpot companies, deals, tickets, and any of Nango's 700+ supported APIs.

Related reading:

Best agentic API integrations platform in 2026

Sapnesh Naik — Fri, 24 Apr 2026 10:26:14 +0000

TL;DR

An agentic API integrations platform is where coding agents (like Claude, Cursor) build API integrations and AI agents in your product call them at runtime. The platform gives you three things in one stack: integrations-as-code (prompted by you and written by your coding agent), a secure, scalable runtime, and Managed Auth for external APIs with data sync. It is the successor to embedded iPaaS (2010s, low-code) and closed unified APIs (early 2020s, narrow scope).

An agentic API integrations platform also enables you to set up just-in-time integrations, where integrations are generated on demand using an AI coding agent and consumed by other AI agents in production.

Three platforms worth evaluating in 2026:

Nango: An agentic API integrations platform supporting 700+ APIs. Coding agents build integrations with the Nango AI builder skill, running against a secure and scalable runtime. AI agents consume those integrations through an MCP server, tool calls, webhooks, and data syncs. Open-source.
Arcade: An MCP-first runtime for agent tool calling with permission checks and evaluation testing. Catalog of 112 first-party integrations, focused on the run side only. Not fully agentic.
Composio: A closed-source tool library for agent integrations across 500+ apps. No code-level customization, no data syncs or webhooks, limited observability. Not fully agentic.

Agentic API integrations: A new platform category

For more than a decade, teams built product integrations by hand. Read the API docs, implement OAuth, handle pagination, write error handling, test, ship, and maintain. A typical team shipped 3 to 5 integrations per quarter. However, customers now ask for integrations with hundreds of tools. Engineering cannot pre-build every use case one at a time.

Two things changed since October 2025:

AI coding agents can build integrations autonomously: Claude Code, Cursor, Codex, and Gemini CLI can read API docs, iterate on a failing request, and produce a working integration. We built 200+ integrations in 15 minutes using OpenCode and the Nango builder skill.
Every AI agent needs API access at runtime: Agents need to read context from external systems to understand the task and take action to complete it. Common examples include fetching a customer record from the CRM, sending a Slack message, drafting an email in Gmail, or updating a ticket in Linear.

These two shifts collapse into the same use case. The agent that uses the integration is increasingly likely to ask another agent to build what it needs. This is the idea behind just-in-time integrations: integrations generated on demand, prompted by an engineer, another agent, or an end customer, rather than pre-built by the platform for every use case. Instead of handcrafting each integration, teams build an integration factory. The more the coding agent does, the less human involvement is needed.

What is an agentic API integrations platform?

An agentic API integrations platform lets engineers and coding agents build, run, and maintain integrations at scale.

1. AI coding agents build integrations:

The platform exposes skills, SDKs, and a testing loop (test runs against real APIs, real credentials, real logs) so a coding agent (like Claude, Cursor, Codex) can author, test, and deploy integrations end to end. Integrations are code in your repo, so your team keeps full version control, review, and audit.

2. AI agents in production consume integrations:

The platform exposes the same integrations as typed tool calls, MCP servers, data syncs, and webhook triggers, so product-facing agents can reliably act on external systems.

3. Developers stay in control:

The integration is code that your engineers can read, review, and edit. Coding agents can write integrations end-to-end, or a human engineer can drive a coding agent with review on every change. The platform supports both modes, so teams move fast without losing control of what ships.

As you can see, the word "agentic" has two implications. On the build side, agents produce the integration code. On the run side, agents consume the integration at runtime. An agentic API integrations platform supports both.

Supporting both the run and the build side matters because platforms that do only one side of the job hit a wall quickly. A tool library without a build workflow cannot quickly scale API integrations, customize integrations for specific customers, or react to schema changes in the external API. A coding assistant without a runtime cannot ship anything to production.

Agentic API integrations platform vs. earlier categories

Category	Era	Builder	Consumer	Limitations
Embedded iPaaS	2010s	Human in a low-code editor	Human end user	Visual builders, AI coding agents cannot build using the platform, nor can AI agents consume integrations
Unified API	Early 2020s	Platform vendor (fixed catalog)	Backend engineers	Constrained schemas, limited categories covered, no customization
Agentic API integrations platform	2026+	AI coding agent or backend engineer in your repo	AI agent in your product, or your SaaS	Emerging category

For deeper context on the older categories, see how Nango differs from embedded iPaaS and unified APIs, what is an embedded iPaaS, and what is a unified API.

What to look for in an agentic integrations platform

Evaluate a platform against the build side, the run side, and the runtime that connects them.

Build side: Can AI coding agents build integrations on it?

A dedicated skill or SDK that encodes integration patterns (auth, pagination, delete detection, checkpoints, error handling) so the agent does not start from a blank file.
Compatibility with the coding agents your team already uses: Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, OpenCode.
A testing command that executes generated code against a real connection and surfaces real API responses, so the agent can iterate on actual errors instead of hallucinating.
Deployment through CI/CD with version control, unlimited environments, and no vendor-specific build pipeline.

Run side: Can AI agents consume integrations at runtime?

A built-in MCP server so agents speak a standard protocol.
Typed tool calls with strict input and output schemas so the LLM does not guess parameters.
Real-time triggers (webhooks, polling) so agents react to provider events, not just initiate requests.
Data syncs to enhance the context of your agent (for example, RAG) and keep data fresh across millions of records.

Runtime and security:

Managed authentication across OAuth, API keys, JWT, basic auth, and MCP Auth.
A white-label, drop-in auth UI so end users authorize under your brand, not the platform's.
Tenant isolation and per-customer resource limits, since one customer's integration should never affect another's.
Deep, real-time observability: full request and response logs, custom log messages, and OpenTelemetry export. Both agents and humans need to read failures.
Per-customer configuration for custom field mappings and tenant-specific behavior.

Use this checklist when evaluating any platform in the category.

Best agentic API integrations platforms

1. Nango

Nango is an open-source agentic API integrations platform. Coding agents can build and maintain integrations on it using the Nango AI builder skill. AI agents inside your product call those integrations at runtime through an MCP server, tool calls, webhooks, and data syncs.

Nango supports 700+ APIs out of the box and is used as core infrastructure by hundreds of fast-growing AI companies.

Best for

Teams building production AI agents that want coding agents to generate integrations on demand, with a secure and scalable runtime to execute them. Includes runtime primitives (MCP, tool calls, syncs, webhooks) to expose those integrations to the AI agents inside a SaaS product.

Pros

AI builder skill for 18+ coding agents: Install with one command, and the skill gives Claude Code, Cursor, Codex, Gemini CLI, OpenCode, and others the context to research an API, write the integration, test it against a real connection, and iterate on real errors. See the walkthrough of building a real-time Google Calendar API integration end-to-end with the Nango AI builder skill.

  # Install the Nango skills for your coding agent
  npx skills add NangoHQ/skills

  <!-- Sample prompt -->

  Build a Nango sync that fetches events from the primary Google Calendar.

  Should run hourly, backfill on initial sync for the last 30 days and
  all future events. After the first run, only fetch future events
  incrementally.

  Return at least:
  - Event title
  - Start and end date
  - Location
  - RSVP status
  - Attendees list (email, display name, response status)

Test generated code against real APIs: AI coding agents use the Nango CLI, which includes a dryrun command that executes generated code against a real connection, returns real responses, and lets the agent iterate until tests pass. This closes the loop that most coding agents lack when building integrations.
Built-in MCP server and typed tool calls: Nango exposes every action as a typed, deterministic tool call through a REST API or MCP server. Agents see clear input and output schemas, reducing the risk of hallucinations.
Beyond tool calls on the same platform: Native data syncs for RAG, webhook processing, polling triggers, per-customer configuration, and an extensible unified API layer. Your agent can read context, react to events, and take actions all within the same platform.
White-label auth across 700+ APIs: A drop-in UI component handles OAuth, API keys, JWT, basic auth, and MCP Auth. Custom credential validation and token refresh are built in. Your end users authorize under your brand.

Low-overhead, tenant-isolated runtime: Tool calls add less than 100ms of overhead. The serverless execution runtime automatically scales during traffic surges and isolates each customer. Syncs use durable checkpoints to resume across millions of records.
Real-time observability with OpenTelemetry: Every operation generates structured logs with full request and response details. Custom log messages, full-text search, and export through OpenTelemetry. A coding agent can read a failing run, find the exception, and fix the code autonomously.

Playground: Trigger syncs and actions from the dashboard to validate end-to-end behavior before wiring them into your product.
Role-based access control: Control who on your team can edit, deploy, or manage integrations and connections.
Enterprise compliance and hosting: SOC 2 Type II, GDPR, HIPAA. Enterprise self-hosting is available for teams that need full data isolation.

2. Arcade

Arcade is an MCP-native runtime for agent tool calling. It exposes a pre-built tool catalog, an SDK for custom MCP servers, and evaluation tools for testing agent behavior against scripted scenarios.

Best for

Teams building MCP-first agents focused on tool calling. Best suited if you don't need broader integration patterns like data syncs or webhooks, or AI coding agent support.

Pros

MCP-native: every tool runs through the Model Context Protocol, which standardizes how agents discover and call tools.
Automatic user permission checks before tool execution.
SDK to build custom MCP servers that run on Arcade's runtime.

Cons

Arcade's SDK targets human developers who write and package custom MCP servers locally. There is no dedicated skill for Claude Code, Cursor, or similar agents. No integrated testing loop against a real connection, and no path for a coding agent to author and deploy a new tool end-to-end inside Arcade.
Tool calls are the only pattern. No data syncs to feed agent context, no webhook processing, no unified API layer.
First-party integrations are approximately 112 as of March 2026 (48 hand-built, 57 auto-generated, plus community contributions).
No per-customer configuration.

3. Composio

Composio is a developer-facing tool library for AI agents. It ships managed auth and a large catalog of pre-built tools wrapped in frameworks like LangChain, CrewAI, Autogen, and the OpenAI Agents SDK.

Best for

Teams that want an MCP server with a large pre-built catalog and managed auth. Best suited for internal productivity or personal automation agents rather than product teams needing custom tools or triggers.

Pros

Catalog of 500+ apps accessible through one SDK.
Managed authentication across supported APIs.
Framework adapters for the most popular agent SDKs.
SOC 2 and ISO certified.

Cons

No custom tools on the platform. You cannot deploy a tool you wrote yourself (or had a coding agent write) onto Composio's runtime. If a pre-built tool does not do what you need, you are blocked until Composio adds it.
No custom triggers. Composio does not let you define webhook or schedule-based triggers for your integrations, so event-driven or scheduled work has to live elsewhere.
There is no dedicated AI builder skill, no repo-level code-generation workflow, and no real API test loop to iterate on integration code.
Tools are closed-source. You cannot inspect or modify the code of a pre-built tool.
No data syncs to feed agent context, no webhook processing, no per-customer tool configuration.
Observability is basic. You cannot add custom log messages, inspect full request and response details, or export traces via OpenTelemetry.

For a deeper comparison, see our best Composio alternatives post.

Comparison table

Capability	Nango	Arcade	Composio
AI coding agent skill (build-time)	Yes, 18+ agents supported	SDK only	None
Test against real API	Yes	Partial	No
MCP server (runtime)	Yes	Yes	Yes
Typed tool calls	Yes	Yes	Yes
Data syncs for agent context	Yes (durable, incremental)	No	No
Webhook processing	Yes (high-throughput)	No	No
Per-customer configuration	Yes	Enterprise only	No
White-label auth UI	Yes, drop-in	Limited	Limited
Open-source templates	Yes	Partial (SDK)	No
Self-hosting	Yes (Enterprise)	VPC, on-prem	No
Primary focus	Full agentic platform (build + use)	MCP runtime	Tool library
Supported APIs	700+	~112 first-party	500+

Why AI coding agents change what "best" means

The short answer is that "best" is no longer about who has the largest closed catalog. It is about the platform that lets your team ship integrations as fast as the coding agent can generate them, and exposes the result to AI agents reliably at runtime.

Three loops compound here:

The Build loop: An integration platform with good coding-agent skills, real-API testing, and secure, real-credential access lets an agent produce a working integration in under an hour. Without that loop, the agent hallucinates endpoints and ships non-working code.
The Run loop: An agentic API integrations platform exposes every integration as a typed tool call or an MCP endpoint, with managed auth and observability, so the AI agent in your product can call it reliably in production.
The Maintain loop: When an integration fails, the logs need to be accessible so that a coding agent, not just a human, can read the exception, trace the failing request, and ship a fix.

Nango is the only platform in this comparison that treats all three loops as first-class, and the only one where the same code an agent builds today runs unmodified in a hardened tenant-isolated runtime tomorrow.

FAQ

What makes a platform "agentic"?

A platform is agentic when AI agents are first-class on both sides. Coding agents can build and deploy integrations with a real testing loop. Product-facing AI agents can call those integrations as tool calls, MCP endpoints, or triggers at runtime.

Is an agentic API integrations platform the same as a unified API?

No. A unified API normalizes data from multiple providers into a single schema. It is built for backend engineers to query a fixed catalog. An agentic API integrations platform is built for AI agents on both sides: coding agents that produce integrations and product agents that consume them. Many agentic platforms can expose a unified API layer when needed, but that is one capability, not the whole category.

Can AI coding agents like Claude Code or Cursor build integrations on these platforms?

Only where the platform ships a dedicated skill or harness. Nango's AI builder skill works with 18+ coding agents and includes a test command that runs generated code against a real connection. Other platforms in this post provide SDKs but do not yet ship a production-grade coding-agent workflow.

Do AI agents need an MCP server?

Not always. MCP is useful when the agent framework expects a standard protocol for discovering tools (for example, Claude Code or agents exposed through LangSmith). Many agent products also use REST APIs for integration, which is simpler and more deterministic. A good agentic platform supports both, so you pick per use case. See our note on avoiding MCP for production reliability, where custom tool calls are a better fit.

How does an agentic integration platform help with just-in-time integrations?

Just-in-time integrations are generated on demand when a customer requests one in your product. The platform provides the sandbox where a coding agent writes the integration, the runtime that executes it with managed auth and tenant isolation, and the observability layer that lets agents read failures and fix themselves. Nango is the open-source factory for this pattern.

Can I use these platforms with LangChain, CrewAI, or the OpenAI Agents SDK?

Yes. All three platforms in this post expose integrations via a combination of REST APIs, MCP servers, and native SDKs that work with LangChain, CrewAI, the OpenAI Agents SDK, the Vercel AI SDK, and the most popular agent frameworks.

Conclusion

The "best agentic API integrations platform" is a simple question with a layered answer: the platform needs to serve AI coding agents that build integrations and AI agents that use them, on a runtime that a team can trust in production.

Nango is the only platform in this comparison that treats both sides as first-class. Coding agents build and maintain integrations through the AI builder skill, testing generated code against real APIs end to end. Product-facing AI agents consume those integrations through an MCP server, tool calls, webhooks, and data syncs. Integrations are code in your repo, running on a secure and scalable runtime, so your team stays in control of every layer while AI agents do most of the work.

Best Arcade.dev alternatives for AI agent integrations in 2026

Sapnesh Naik — Tue, 21 Apr 2026 06:34:25 +0000

TL;DR

Arcade.dev is an MCP runtime that executes authenticated tool calls for AI agents. It works well for MCP-first teams that need a hosted runtime and user-scoped auth. But production AI agents usually need more than tool calls: continuous data syncs for RAG, webhook ingestion, and deep observability across API integrations.

If you are evaluating alternatives, pick the one that covers your full integration surface: not just the tool calls you need today, but the data syncs, webhooks, auth, and observability your agents will need once they ship to real customers.

Top Arcade.dev alternatives for 2026:

Nango: Best for teams building production AI agent API integrations that need tool calls, data syncs, webhooks, and auth on a single code-first platform. Supports 700+ APIs with open-source tools and works with Claude Code, Cursor, and other AI coding agents.
Composio: An MCP-native alternative aimed mainly at internal and personal automation agents. Larger pre-built catalog than Arcade (500+ apps), but closed-source tools and no data syncs, webhooks, or per-customer configuration.
Pipedream Connect: Fits teams that prefer a low-code, UI-based workflow builder with a large action library.
Merge Agent Handler: Fits teams that want pre-built MCP tool-packs for common SaaS actions and don't need custom tool logic or data syncs.

Why teams look for Arcade.dev alternatives

Arcade.dev positions itself as the MCP runtime that makes AI agents production-ready. It handles OAuth, runs tool calls, and supports server-level and tool-level authorization.

That positioning works well for a specific profile: teams that are already committed to MCP, want a hosted runtime, and only need tool calls. But as teams move from prototyping to production API integrations, several limitations surface.

Drawbacks of using Arcade for production AI agent integrations:

Tool calls only: Arcade is a tool-calling runtime. It does not offer data syncs (for RAG pipelines), webhook ingestion, polling triggers, or unified APIs. If your AI product needs external data continuously kept up to date, or if it must react to events in Salesforce, HubSpot, or other systems, you need a separate platform.
Narrow first-party catalog: Arcade lists around 24 first-party OAuth providers, which is materially smaller than other platforms in this comparison. Many APIs are only reachable through community MCP servers of varying quality and maintenance.

MCP-dependent architecture: Every tool call flows through MCP. That is useful for prototyping, but generic MCP servers can reduce reliability in production: broad tool definitions inflate the LLM's context, and handing off multi-step logic to the agent increases hallucination risk.
Limited observability: Arcade provides basic logs of tool executions. Teams that need full request and response payload inspection, custom log messages inside a tool, or OpenTelemetry export find the logging surface narrow.
For example: During our testing, we ran a suggested /reddit tool call inside Arcade's Playground. It failed with an invalid Client ID error, but the failed execution never showed up in the Audit Logs page. Small gaps like this point to a platform that is still maturing in production, where several features are described as aspirational or in progress.

No per-customer configuration: Arcade tools are defined at the server level, not per tenant. There is no built-in support for tenant-specific custom field mappings, per-customer tool behavior, or custom auth validation. Every customer gets the same tool surface.

These constraints are manageable for chat assistants and prototypes. They become real limits when AI agents are a core product feature that must run reliably across customers.

Best Arcade.dev alternatives

1. Nango

Overview

Nango is an open-source integration platform for AI agents and SaaS products. It provides a unified interface for API auth, custom tool calls, data syncs, webhooks, and an MCP server, all on a single platform.

Nango supports 700+ APIs out of the box and is used by hundreds of fast-growing AI agent companies as core infrastructure for their API integrations.

Best for

Teams building production AI agent API integrations that need tool calls, data syncs for RAG, webhooks, and auth across a wide range of APIs on a single code-first platform.

Pros

Broad API coverage across 700+ APIs: Pre-built auth for OAuth, API keys, JWT, basic auth, and the new MCP Auth standard. White-label by default, so end users authorize your app, not Nango. You can also contribute support for new APIs yourself.

Code-first with AI coding agent support: Tool definitions are functions that live in your git repo and deploy through CI/CD. The Nango AI Integration Builder works with Claude Code, Cursor, Codex, or any AI coding assistant, so you can generate and iterate on custom tools, syncs, and webhook handlers in minutes.

  # Install the Nango skills for your coding agent
  npx skills add NangoHQ/skills

  <!-- Sample prompt -->

  Build a Nango sync that fetches events from the primary Google Calendar.

  Should run hourly, backfill on initial sync for the last 30 days and
  all future events. After the first run, only fetch future events
  incrementally.

  Return at least:
  - Event title
  - Start and end date
  - Location
  - RSVP status
  - Attendees list (email, display name, response status)

Open-source, customizable tools: Nango's pre-built integration templates are open source. You can clone an existing tool, modify it for your use case with a coding agent, and deploy it to your account. This is the opposite of the closed tool model used by many MCP-first platforms.
Built-in MCP server: Nango exposes your custom tool calls through an MCP server. The flow is Agent to Nango MCP to your own custom tools. That keeps the agent's context focused on the specific tools you have built instead of flooding it with hundreds of generic ones.
Beyond tool calls, on the same platform: Native resumable data syncs (for RAG), webhook processing, polling triggers, and per-customer configuration. A built-in Playground lets you test tool calls, syncs, and triggers interactively before wiring them into your agent, and role-based access control (RBAC) scopes access across teammates.
Deep real-time observability: Every operation generates detailed logs with full API request and response details, error messages, and custom log messages. Everything exports via OpenTelemetry.
Scalable runtime with low overhead: Nango adds less than 100ms overhead on tool calls, isolates each customer's executions with tenant-level fairness, and auto-scales under webhook bursts.
Enterprise-grade compliance: SOC 2 Type II, GDPR, and HIPAA compliant. Enterprise self-hosting and VPC deployments available.

2. Composio

Overview

Composio is an AI agent integration platform with a catalog of 500+ apps. It acts as an MCP gateway: every integration is automatically exposed through a standardized MCP interface, on top of managed OAuth and pre-built tool definitions.

Best for

Teams building internal or personal automation agents that want an MCP-native alternative to Arcade with a larger pre-built catalog and managed auth, and that do not need data syncs, webhooks, or per-customer configuration.

Pros

Larger catalog than Arcade: Pre-built tool definitions across 500+ apps, covering Slack, GitHub, Notion, Gmail, Salesforce, and more.
MCP gateway: Every integration is auto-exposed through MCP so you can expose tools to MCP-Compatible clients (like Claude Desktop, Cursor)
Managed OAuth: Handles token acquisition, refresh, and scope management out of the box.
Broad framework support: Works with LangChain, CrewAI, OpenAI Agents SDK, and the Vercel AI SDK.

Cons

Closed-source tools: You cannot inspect or modify the code of Composio's pre-built tools. If a tool does not match your requirements, you build a replacement from scratch outside the platform.
No data syncs or webhooks: Composio focuses on tool calls. RAG pipelines that need continuously updated external data, or agents that react to real-time events, require a separate system.
Limited per-customer configuration: Every customer gets the same tool behavior. Tenant-specific field mappings, custom auth validation, or per-customer tool logic are not supported.
Observability constraints: Basic execution logs. Custom log messages inside tool code and OpenTelemetry export are limited compared to code-first platforms.

3. Pipedream Connect

Overview

Pipedream Connect is the embedded version of Pipedream's serverless integration platform. It exposes MCP servers per app and gives agents access to a large library of pre-built actions across 2,800+ apps.

Best for

Teams that prefer a low-code workflow builder and need wide catalog coverage for internal-facing or lightly customized agent use cases.

Pros

Large action library: 10,000+ pre-built actions across 2,800+ apps give agents a wide default surface area.
MCP server per app: Dedicated MCP servers per supported app, so agents can discover and call tools through the protocol.
Low-code workflow builder: Useful for teams that want to assemble multi-step tool-call logic visually.

Cons

Acquired by Workday: Pipedream was acquired by Workday (an Enterprise HR platform) in November 2025. You can read their announcement here.
Non-standard action schemas: Action inputs use Pipedream-specific types ("alert props," "dynamic props," "external props") that require a learning curve and limit compatibility with external tooling.
Complex action configuration: Most actions must be "configured" before they can run, often requiring 2-5 additional API requests. That adds latency and friction for background agents.
No data syncs: Pipedream Connect does not offer scheduled or incremental data syncs, so RAG implementations need another platform for ongoing data ingestion.
Limited white-label auth: End users see Pipedream branding and consent to Pipedream during OAuth, which is a problem for enterprise-facing products.

4. Merge Agent Handler

Overview

Merge Agent Handler is a separate product from Merge's traditional unified API. It lets teams create custom MCP servers with specific pre-built Merge integrations enabled, giving an AI agent a defined set of capabilities.

Best for

Teams that only need pre-built MCP tool-packs for common SaaS actions (for example, fetch tickets from Linear, create an issue in GitHub) and do not need custom tool calls, data syncs, or custom object and field support for CRM and ERP integrations.

Pros

Pre-built tool-packs: Bundle relevant integrations for a specific agent and restrict the available tools, for example a read-only tool-pack for ticketing.
Playground: A testing environment to validate MCP behavior before deploying.
Public MCP import: You can import any public MCP server and edit tool schemas to fit your agent.

Cons

Narrow connector library: Merge Agent Handler supports around 110 pre-built connectors. If the API you need is not covered, you fall back to public MCP servers.
No custom tool calls: You cannot build custom tool logic on the platform. Agents are constrained to the pre-built surface, which can force the LLM to chain multiple tool calls for a single business action.
No Custom fields support: Pre-built tools do not handle custom fields or objects well, which is common in enterprise Salesforce or HubSpot deployments.
No data syncs: No support for continuous data syncs, so RAG pipelines need a second platform.
MCP Auth gaps: Some APIs, such as HubSpot's remote MCP server, require MCP Auth. Merge Agent Handler currently supports standard (non-MCP) auth for most providers.

Comparison of Arcade.dev alternatives

Feature	Nango	Composio	Pipedream Connect	Merge Agent Handler
Primary focus	Agentic, code-first AI agent and product integrations	MCP-first tool calling	Low-code embedded workflows	Pre-built MCP tool-packs
Supported APIs	700+	500+	2,800+	~110
Tool customization	Full (code-first, open source)	Limited (closed tools)	Low-code workflows	No custom tool code
AI agent (LLM) tool calls	Yes (custom, code-first)	Yes (pre-built)	Yes (pre-built actions)	Yes (pre-built)
AI coding agent support (Claude Code, Cursor)	Yes (optimized tools and skills)	No	No	No
MCP server	Yes (on your custom tools)	Yes (auto on all tools)	Yes (per app)	Yes
Data syncs for RAG	Yes (native, incremental)	No	No	No
Webhook processing	Yes (high throughput)	No	Triggers only	No
Per-customer configuration	Yes	Limited	Limited	Limited
Observability	Deep (OpenTelemetry, custom logs)	Basic	Basic	Basic
Auth model	White-label (your brand)	Managed	Pipedream-branded	Platform-managed
Open source	Yes	Partial (closed tools)	Partial	No
Self-hosting	Yes (Enterprise)	No	No	No

How we evaluated these platforms

We assessed each Arcade.dev alternative across five dimensions that matter for production AI agent integrations:

Catalog breadth and extensibility: How many APIs are supported out of the box? Can you add new APIs yourself without waiting on the vendor?
Tool customization: Can you build and modify tool logic in code? Can AI coding agents (Claude Code, Cursor, Codex) help generate or refactor tools?
Integration patterns beyond tool calls: Does the platform support data syncs for RAG, webhooks, polling triggers, and per-customer configuration?
Observability: Are there full request and response logs, custom log messages inside tool code, and OpenTelemetry export?
Deployment and auth model: Is auth white-label and tenant-safe? Is self-hosting available for regulated workloads?

Which alternative should you choose?

You are building production AI agent integrations with broad requirements: Choose Nango. It is the only platform in this comparison that combines pre-built tool calls, data syncs, webhooks, and unified APIs on a single code-first platform, with 700+ APIs and AI coding agent support for building custom tools fast.

You want an MCP-native alternative to Arcade with a larger catalog: Consider Nango or Composio. They both give you pre-built tools behind an MCP gateway.

You prefer a low-code workflow builder with a large catalog: Pipedream Connect fits, especially for internal-facing agents.

You only need standard, pre-built tool-packs: Merge Agent Handler can work for ticketing, CRM reads, and other common SaaS actions. Confirm that your APIs are supported and that you do not need data syncs or deep customization.

FAQ

What is the best Arcade.dev alternative for production AI agents?

Nango is a strong fit for teams building production AI agent API integrations. It supports 700+ APIs, code-first custom tool calls with AI coding agent support, data syncs for RAG, webhooks, and deep observability with OpenTelemetry. Unlike Arcade, it is not limited to tool calls and exposes an MCP server on top of your own custom tools instead of relying on public MCP servers.

Does Arcade.dev support data syncs or webhooks?

No. Arcade.dev is a tool-calling runtime. It does not provide scheduled or incremental data syncs, webhook ingestion, or polling triggers. If your AI agent needs continuously updated external data for a RAG pipeline, or must react to events in Salesforce or HubSpot, you need a separate platform. Nango supports all of these on a single platform alongside tool calls.

Is Arcade.dev open source?

Arcade.dev's SDK and MCP server framework are open source, so you can build custom MCP servers and self-host. The platform itself (runtime, catalog, managed auth) is a hosted product. Nango, by contrast, is fully open source on GitHub, and all of its pre-built integration templates are open and editable.

Can I use Arcade.dev alternatives with LangChain, CrewAI, or the OpenAI Agents SDK?

Yes. Nango, Composio, Pipedream Connect, and Merge Agent Handler all expose tools through standard interfaces (REST APIs and/or MCP servers) that work with any agent framework. Nango's MCP server and REST API integrate with LangChain, CrewAI, OpenAI Agents SDK, Vercel AI SDK, and Mastra. Composio is MCP-native and works with any MCP-compatible client.

Can I build custom tools with Arcade.dev alternatives using AI coding agents?

No, not with Arcade itself. But Nango is designed for this: tool definitions are code, and the Nango AI Integration Builder provides skills for Claude Code, Cursor, and other coding assistants to generate and refine tool calls, data syncs, and webhook handlers. Composio, Arcade, Pipedream Connect, and Merge Agent Handler do not ship dedicated AI coding agent integrations for building tools on their platforms.

Conclusion

Arcade.dev is a focused MCP runtime that fits teams with strict MCP-first requirements and simple tool-calling workloads. Once AI agent integrations become a core product surface, the tool-calling-only scope, narrow first-party catalog, and basic observability start to matter.

Nango covers the broadest set of production requirements on a single platform: 700+ APIs, custom tool calls, data syncs for RAG, webhooks, unified APIs, and deep observability, with AI coding agent support for building everything fast. Composio is a closer direct alternative to Arcade if your scope stays inside MCP tool calls. Pipedream Connect and Merge Agent Handler cover narrower low-code and pre-built use cases.

Start with the hardest integration requirement in your product roadmap. The platform that handles it today will carry you further as your AI agents scale.

Related reading: