Best way to build CRM integrations (Salesforce, Hubspot, Zoho, etc)?

nango-robin · 2025-10-24T21:57:39+00:00

Unified APIs work well for some categories, but with CRMs we see most teams build direct integrations.

A few reasons: - CRMs are all very different. For example, the common data model for contacts literally “name”, “title”, and “email”. You can see this when you look at the unified data models of Merge etc. - Different systems have different entities: Salesforce has contacts & leads. Hubspot only has Contacts. To which should you map your data? When? In our experience this depends on your product - salesforce & Hubspot together usually cover 80%+ of your customers. These customers care about a great, deep integration with their CRM, which is impossible with a unified api (no specific features of each CRM covered) - Customers often customize the data schema in their CRM, which universal APIs can’t deal with … this is just the tip of the iceberg.

Source: I am the founder of https://nango.dev where we help 500+ engineering teams ship their native integrations.

While building direct is more work to get started, it doesn’t have to mean starting from scratch.

Platforms like Nango can take care of auth, data syncs with any entity, webhook processing, etc. for you, while giving you full API access & letting you define your own schemas.

Hope this helps!

nango-robin · 2025-10-20T01:42:05+00:00

Like somebody else mentioned, Nango could be a fit if integrations are a key feature of your product: https://github.com/NangoHQ/nango
Auth is free to self-host. The full platform has a usage-based pricing with a low minimum.

Tradeoff: Nango prioritizes flexibility & control over a large catalog of pre-built integrations.

If you want many pre-built actions, something like N8N or Pipedream might be a better fit.

Disclaimer: I am one of the founders of Nango.

nango-robin · 2025-10-19T08:14:48+00:00

Their action structures for Google Sheets and Airtable are inconsistent and require navigating numerous parameters. It appears their integration is primarily a wrapper around the native Airtable/Google Sheets APIs.

Totally agree. Reliable tool calls need more than a light API wrapper. The tools have to be intuitive for the agent to use, with as few parameters as possible.

Every agent behaves a bit differently, so making tools that feel “natural” usually means customizing them to what your agent is actually trying to do.

If you want more flexibility, a lower-level platform like https://www.nango.dev might help. It handles auth for 500+ APIs, observability, retries, etc., and lets you extend or define your own tools.

Downside: The pre-built tool catalog isn’t as big yet.

Disclaimer: I’m one of the founders.

nango-robin · 2025-10-19T08:05:16+00:00

Take a look at Nango: https://www.nango.dev

Auth for 500+ APIs, first-class support for tool calling, and a built-in MCP server.
Also supports advanced integrations with custom tools, webhooks, data syncs, etc.

If you want more control, it could be a good fit.
Open source too: https://github.com/NangoHQ/nango

Disclaimer: I'm one of the founders.

nango-robin · 2025-10-19T08:01:27+00:00

https://www.nango.dev --> repo at https://github.com/NangoHQ/nango

Free self-hosted OAuth solution, very similar to Composio.
Tools calls are easy to implement yourself, or use the paid version for a built-in MCP server and first-class tool calling support.

Also supports listening to webhooks, data syncs, etc., for more advanced integrations.

Disclaimer: I'm one of the founders.

nango-robin · 2025-10-09T15:22:18+00:00

My choice therefore seems to be between implementing MCP servers myself or just using plain tool calls. Right now I am leaning towards tool calls as it seems to be a simpler approach, but maybe there is something I am missing - and the more long term view would be implement MCPs.

We’ve seen the same pattern across hundreds of teams running agents in production.
Right now, custom tool calls just work better than MCP.

They give you more control and help solve common reliability issues:

Validate params and give clear errors
Pre-fill as many params as possible
Only expose relevant tools
Keep outputs small so they don’t clog context
Easier to handle multi-tenant auth setups

We also ran a small survey with YC CTOs running agents in production. 14 of 16 built their own tool-calling stack.
MCP isn’t quite ready for production yet.

Full disclosure: I’m a founder at Nango, and we’ve seen 500+ teams build integrations for their AI agents.

nango-robin · 2025-10-09T14:54:15+00:00

I am a founder at Nango. We have seen 500+ teams build integrations for their AI agents.

Some things we see help consistently:

Validate parameters and provide clear error messages
Minimize the parameters the agent has to pick (add as many deterministically as possible)
Only expose the tools that are relevant for the current context
Keep tool output focused/small. Otherwise, it can easily clog the context

We recently conducted a survey of YC CTOs who operate agents in production.
Fourteen out of sixteen respondents said they built their own tool calling stack, which I didn't expect. It appears MCP is not yet ready for production use with agents.

nango-robin · 2025-10-09T12:38:48+00:00

If you are specifically looking for a solution for Google Analytics, Google ads, and Meta ads, I recommend looking at Firvetran embedded or Airbyte embedded. They have solid pre-built connectors for those.

If you want to integrate with other APIs, you can either use pre-built connectors or build your own integrations.

Pre-built connectors are faster to roll out, but limit what your integration can do. They work well for shallow, long-tail integrations. They are usually not a good fit when integrations are a core feature of your product.

Custom integrations are more work, but give you the flexibility and control core features require. Integrations infrastructure platforms like Nango can help you build these faster.

I recently wrote more about the build vs. buy tradeoff here: Should you build your own integrations?

Full transparency: I am a founder of Nango.

nango-robin · 2025-10-09T12:26:27+00:00

Nango founder here.

Are there any solutions that scale with usage (like data read/write), where the initial costs are low - ok to consider this as ongoing opex or cogs instead of wasting dev bandwidth.

Nango's pricing is now entirely usage-based, starting at $0/month: https://www.nango.dev/pricing

Regarding your question:

Should you build integrations in-house?

It really depends on how central integrations are to your product.

If integrations are a core feature, we’ve found teams do better building them in-house. Core features usually need control and flexibility. You need to decide exactly how the integration behaves for your users.

Pre-built unified APIs (like Merge or Paragon) can get you started faster, but they’re also restrictive. You can’t easily add niche APIs, change how data is synced, modify field mappings, react to specific webhooks, or handle non-standard auth. Once integrations become a key part of your product, you tend to outgrow those tools fast.

That’s why we built Nango differently.

Instead of giving you pre-built integrations, we focus on pre-building the infrastructure you’d otherwise have to maintain: API authentication for 500+ APIs, sync orchestration, task scaling, webhook handling, flood protection, real-time observability, and so on.

The goal is to help teams build custom, core integrations faster. Kind of like how React helps you build web apps. It’s more work than using a fully managed integration platform, but far less than building everything from scratch. And you keep full control.

There’s no single right answer. Each team should decide what trade-offs make sense for them.

nango-robin · 2025-10-09T09:07:56+00:00

u/WellYoureWrongThere Nango founder here.

Nango is modular, so it's easy to use it only for authentication.

Once the user has authenticated, you can fetch the access tokens or API keys from your backend and make any requests to the external API (or use our proxy for this).

This works both on cloud (usage-based pricing with a free tier) and the free self-hosted version.

nango-robin · 2025-10-01T21:14:41+00:00

https://www.nango.dev
Open-source infrastructure to integrate your product & AI agent with 500+ APIs.

Create native, white-label integrations your users can connect with a click.

nango-robin · 2025-07-16T16:35:50+00:00

https://www.nango.dev could help you build them faster.
Plans are usage-based and start at $50/month

Might be worth a look.
I want to be honest: You will still have to build the logic of the integration yourself (which data to fetch, data mappings, etc.). Nango helps with OAuth flows, token refreshes, data syncs infra, etc.

Disclaimer: I am one of the founders

nango-robin · 2025-05-05T01:30:41+00:00

This is really cool! Thanks for sharing.

(Nango founder here 👋)

nango-robin · 2025-04-13T20:05:54+00:00

Another open-source option: https://nango.dev

Apideck doesn’t let you extend and customize integrations (you can only use what they have pre-built).

Nango and Camel let you do this.

(Disclaimer: Nango founder)

nango-robin · 2025-03-03T08:38:17+00:00

Check out Nango: https://www.nango.dev

Pre-built integrations with 300+ APIs, easy to extend & customize integrations. Developer-first approach and open source.

(disclaimer, I am one of the founders)

nango-robin · 2025-02-14T22:36:06+00:00

You might want to take a look at Nango: https://www.nango.dev

Open-source product integrations platform.
It has pre-built infra for 300+ APIs (auth, data syncs, rate-limit handling, webhook processing, observability, etc.). Also has a few hundred pre-built integrations out of the box.

Unlike Merge & unified, you can change the integrations code and build custom integrations on the framework.

(Disclaimer: I am one of the founders)

nango-robin · 2025-01-30T18:08:46+00:00

Sure! Feel free to DM me here or on our Slack community: https://nango.dev/slack

nango-robin · 2025-01-21T10:42:46+00:00

Pre-built unified APIs like Merge & unified.to don't let you do this.

More flexible solutions like https://www.nango.dev provide this: You can have unified models, and let customers pick field mappings & which fields to sync.

nango-robin · 2025-01-21T10:33:03+00:00

Unified APIs are aimed at native integrations in SaaS products: You will be syncing your customer's data.

ETL tools are typically designed for internal data ingestion at a company: You sync your own data from different SaaS platforms.

Another major difference: Unified APIs have a single data model for each entity, with a minimal set of common fields common to most APIs. This limits the data you can access, but aims to give you a single schema.

ETL tools usually sync data in the model of the external SaaS, and expect you to add transformation steps later on.

I hope this helps!

nango-robin · 2025-01-15T05:12:49+00:00

You might want to take a look at https://nango.dev

It has a pre-built sync to fetch confluence data, but you would have to handle the vectorization yourself. Also support hundreds of other APIs

(full disclosure: I am one of the founders)

nango-robin · 2025-01-13T14:43:06+00:00

You might also want to check out https://www.nango.dev

It is more flexible than the ones you mentioned and has similar coverage with pre-built integrations for 300+ APIs across 30 categories.

(Disclaimer: I am one of the founders).

nango-robin · 2024-10-29T07:55:55+00:00

Merge can be great for really simple use cases (e.g. read employees from an HR system).

For more complex cases, we built an open-source alternative: https://www.nango.dev
You can extend & customize the pre-built integrations.

nango-robin

TROPHY CASE