Updated June 24, 2026 by Sunny Chauhan.

When a HubSpot customer says "does it integrate with X?" the honest answer is "depends on what kind of integration you mean." HubSpot has four flavors and they're not interchangeable. A first-party native integration behaves differently from a Marketplace ISV app, which behaves differently from a custom integration your team built, which behaves differently from a Zapier flow. Customers (and the founders selling to them) regularly conflate these and get confused about why one slack-style integration costs $0 and another costs $30,000. Here's the four-way breakdown: what each is, when it's the right choice, what it costs, and the trade-offs nobody mentions until contract time.

Pro Tip

TL;DR Four kinds of HubSpot integrations: 1/ Native (built and maintained by HubSpot itself, free), 2/ Marketplace apps (built by third-party ISVs and listed on HubSpot Marketplace, free to install but the app vendor charges separately), 3/ Custom integrations (you build it yourself against HubSpot's APIs, no Marketplace listing), 4/ Middleware (Zapier, Make, iPaaS platforms that connect HubSpot to other systems). Native and Marketplace are the buyer-facing options. Custom and middleware are how you build your own.

Built and maintained by HubSpot itself. They appear inside HubSpot's settings as first-party integrations. Examples: Gmail, Outlook, Slack (the official HubSpot-built one), Microsoft Teams, Salesforce (HubSpot's own connector), Zoom.

Characteristics: → Configured directly in HubSpot's UI → No third-party billing (included with HubSpot subscription) → Maintained by HubSpot, so they survive HubSpot product changes → Limited to whatever HubSpot has built

For customers: easiest path. If HubSpot has a native integration with the system you care about, use it.

For ISVs: this is a tier you can't compete with on the same product. If HubSpot ships a native X integration, your X integration competes on features and depth, not on existence.

Built by third-party ISVs (companies like you) and listed on the HubSpot App Marketplace. Customers install them like first-party integrations but the app is owned and maintained by the third party.

Characteristics: → Installed via the Marketplace listing → Free to install; the app vendor handles billing separately → Vendor owns maintenance and roadmap → HubSpot reviews and (optionally) certifies them → ~2,000 apps as of 2026

For customers: middle-of-the-road path. More choice than native, more reliability than custom.

For ISVs: the primary distribution channel. See our HubSpot Marketplace complete guide.

A custom integration is one you (or your engineering team) built against HubSpot's APIs, not listed on the Marketplace. Could be your own product talking to HubSpot. Could be a one-off connector between HubSpot and your internal tooling.

Characteristics: → Lives in your infrastructure → Uses OAuth (or Private App tokens for single-portal cases) → No Marketplace presence → Costs your engineering time to build and maintain → You can do anything HubSpot's API supports

For customers: bespoke path. Right when no native or Marketplace option fits.

For builders: see our HubSpot custom integration build guide.

A middleware platform sits between HubSpot and another system, orchestrating the flow. Zapier, Make (formerly Integromat), Tray, Workato. The customer configures a flow (e.g., "when a contact is created in HubSpot, do X in Y").

Characteristics: → Customer configures the flow themselves → Platform charges based on usage (per-task, per-flow-run) → Best for simple, low-volume automations → Doesn't scale economically at high volume → Customer (or platform) maintains the flow; not the vendors at either end

For customers: fastest path for simple needs.

For ISVs offering a HubSpot integration: middleware is a way to extend reach without building a Marketplace app, but limits depth.

When a customer asks "how should I integrate HubSpot with X?", two questions determine the answer:

→ Native exists: use the native one unless it's missing a specific feature you need. → Marketplace app exists: install it. Compare to native if both options. → Neither exists: continue to Q2.

→ Simple flow, low volume: middleware (Zapier, Make). Fast, cheap, breaks at scale. → Deep integration, business-critical: custom. Costs eng time but you own the depth.

For most customers, Q1 ends the discussion. The interesting cases are when neither exists and they have to choose between middleware and custom.

Rough cost ranges for a typical "sync data between HubSpot and another system" integration:

→ Native: $0 → Marketplace: vendor's pricing (often $0 for SMB, scales up) → Custom: $20K-$50K to build, $5K-$10K/yr maintenance → Middleware: $200-$1000/yr Zapier subscription

For one customer, middleware wins on cost. Custom wins on depth.

→ Marketplace: list once, every customer can install. Engineering investment to build the app. → Custom (per customer): expensive engineering per customer; doesn't scale. → Middleware (Zapier-style integration partner): possible but limits depth. → Embedded iPaaS (Paragon, Merge, Workato Embedded): white-label middleware in your product. Scales well, costs platform fees.

For 100 customers, Marketplace listing is usually right.

→ Marketplace: same investment, much better per-unit economics. → Custom one-by-one: not viable. → Middleware/embedded: platform fees start to dominate. At 5000+, native Marketplace app dominates on unit cost.

Customers (and search queries) conflate these terms constantly. When someone says "HubSpot integration with Salesforce", they could mean:

→ HubSpot's first-party native Salesforce connector (one specific product) → A third-party Salesforce-HubSpot Marketplace app (multiple of these exist) → A custom-built connector their internal team wrote → A Zapier flow that moves data between the two

Each has different features, different costs, different reliability. When writing copy for HubSpot integration topics, name the specific kind. "HubSpot's native Salesforce integration" beats "HubSpot Salesforce integration" because the latter is ambiguous.

At Appnigma we generate Salesforce 2GP Managed Packages, which is the Salesforce equivalent of a Marketplace app. For HubSpot, the same model would generate Marketplace-listable native apps from natural-language prompts. The economics: today building a custom HubSpot integration takes 8-12 weeks of engineering; no-code generation would compress that to days. The cost equation shifts: custom integrations become as cheap as middleware while keeping the depth.

This isn't shipped for HubSpot yet but the patterns are documented in the Salesforce-side work.

• [ ] Checked if HubSpot has a native integration for the system → Yes / No

• [ ] Searched HubSpot Marketplace for relevant apps → Yes / No

• [ ] Considered whether the integration needs to be deep (real-time, bidirectional) → Yes / No

• [ ] Estimated volume of operations per day → Yes / No

• [ ] Compared total cost over 12 months for each option → Yes / No

• [ ] Decided who maintains it if HubSpot changes their API → Yes / No

A 50-person SaaS company wanted to sync HubSpot deal-stage changes to their internal billing system. Three options on the table:

→ Marketplace: no app existed that did exactly what they wanted → Custom integration: ~6 weeks of engineering, $20K → Middleware (Zapier): $400/year subscription, configurable in an afternoon

They picked Zapier. Got it working in 2 hours. Six months later they hit Zapier's task limit on a busy month and the bill ticked up. Two years later they were at $4K/year and the flow occasionally lagged.

At the 2-year mark they decided to build custom. The pattern: middleware bought them time to validate the integration before investing in custom. The total cost over 2 years was higher than custom would have been from day one, but they didn't have to commit eng time upfront.

The honest read: middleware-first is a defensible choice for ambiguous-value integrations. Custom-first is right when you know the integration is durable and high-volume.

1/ Native (built by HubSpot), 2/ Marketplace apps (built by third-party ISVs and listed on HubSpot Marketplace), 3/ Custom integrations (you build it yourself against HubSpot's APIs), 4/ Middleware (Zapier, Make, iPaaS platforms). Each has distinct cost, depth, and maintenance characteristics.

Native integrations are built and maintained by HubSpot itself (Gmail, Slack, Outlook, etc.). Marketplace apps are built by third-party ISVs and listed on the HubSpot App Marketplace. Native is free and HubSpot-maintained; Marketplace apps are free to install but the vendor handles billing and maintenance.

HubSpot maintains roughly 50-100 native integrations. The HubSpot App Marketplace has roughly 2,000 third-party Marketplace apps. Custom integrations (every company's internal connectors) and middleware-based flows aren't centrally counted.

Use a Marketplace app if one exists that fits your needs (it's free to install and someone else maintains it). Build custom only if no Marketplace app does what you need, the integration is critical to your business, and you have eng resources to maintain it.

Native: $0. Marketplace: $0 to install, vendor bills separately (varies). Custom: $20K-$120K to build, $5K-$20K/yr maintenance. Middleware: $200-$4K+/yr Zapier-style subscription. Embedded iPaaS: $30K-$200K/yr. See our HubSpot integration platform patterns for the full cost framework.

Yes, multiple ways. HubSpot ships a native Salesforce connector. The Marketplace lists multiple third-party HubSpot-Salesforce apps. Some customers build custom connectors via API. See our HubSpot Salesforce integration guide for the comparison.

No. Marketplace listings must use direct OAuth integration with HubSpot's APIs. A Zapier flow or Make scenario isn't a Marketplace-listable app.

Check HubSpot's app drawer in your portal settings, or browse HubSpot's integrations directory. Native integrations are tagged by HubSpot directly; third-party Marketplace apps are tagged by their vendor.

Sunny Chauhan is the founder and CEO of Appnigma AI, a no-code platform that generates Salesforce AppExchange-ready Managed Packages from natural-language prompts. He holds Salesforce certifications in Platform Developer II, Platform App Builder, Administrator, Data Cloud Consultant, and AI Associate. Appnigma generates the Salesforce equivalent of HubSpot Marketplace apps; the type-selection logic above (native vs Marketplace vs custom vs middleware) maps to the Salesforce ecosystem one-to-one.

Originally published June 24, 2026. Last reviewed June 24, 2026. Integration type descriptions and cost ranges based on HubSpot's published documentation and ISV market data current as of the published date.

• HubSpot Marketplace Complete Guide

• HubSpot Custom Integration Build Guide

• HubSpot Integration Platform Architecture Patterns

• HubSpot CRM Integrations Builder's Guide

• HubSpot Integration Providers and Services

• HubSpot Salesforce Integration Guide

• HubSpot API Builder's Guide

1/ HubSpot Ecosystem, App Marketplace 2/ HubSpot Developers, API Documentation Overview 3/ HubSpot Knowledge Base, Connect Apps to HubSpot 4/ HubSpot Developers, OAuth Quickstart Guide

Which kind of integration does your team currently maintain, and is it still the right type 12 months in?