Updated June 25, 2026 by Sunny Chauhan.

I get the same question from operations leaders every month: "We use HubSpot for marketing and Salesforce for sales, what's the best way to connect them?" The clean answer isn't a vendor pick, it's a sync-direction decision. Most teams pick a connector before they decide which direction data should flow, which fields should sync, and what happens when both sides edit the same record. That decision sequence is backwards and it's why integration projects routinely take three months when the technical setup is a 2-hour job. Here's the full 2026 guide: three connector options (HubSpot's native, third-party Marketplace, custom build), how to decide sync direction and field mapping before touching any tool, and the gotchas that derail integrations in month two.

Pro Tip

TL;DR Three ways to integrate HubSpot with Salesforce: 1/ HubSpot's native Salesforce connector (free, fast, limited customization), 2/ Third-party Marketplace apps like Bardeen, Tray, Workato, or Cloud Elements (paid, more flexible), 3/ Custom build via Salesforce Connected App + HubSpot OAuth (deepest, most expensive). Decide three things first: which direction each record type syncs, which fields map, and conflict resolution policy. Then pick the connector. The native HubSpot connector handles 80% of mid-market needs. Custom builds are right for unique business logic that no connector models cleanly.

HubSpot built and maintains an official Salesforce integration. Installed from HubSpot's settings → Integrations → Salesforce. Free with HubSpot subscription.

What it handles: → Bidirectional sync of contacts, companies, deals (called Opportunities in Salesforce) → Lead-to-contact conversion mapping → Custom field mapping (admin-configured) → Selective sync rules (which records sync based on filters) → Conflict resolution (last-modified-wins by default)

What it doesn't handle: → Custom Salesforce objects (only standard objects supported in most tiers) → Complex multi-step transformations → Real-time sub-second sync (it's near-real-time, not instant) → Bidirectional file or attachment sync

For most mid-market teams using both platforms in standard ways, the native connector is the right choice. Free, HubSpot-maintained, no third-party dependency.

Apps listed on HubSpot Marketplace (and often AppExchange too) that bridge HubSpot and Salesforce. Examples in 2026: Bardeen, Tray.io, Workato, Cloud Elements, and a handful of specialist syncers.

When they fit: → The native connector doesn't model your business logic → You need custom object sync → You want fine-grained transformation rules → You need orchestration across more than just HubSpot ↔ Salesforce

Cost ranges from $500/yr (simple connectors) to $30K+/yr (enterprise iPaaS). The "more is better" trap is real: don't pay for an iPaaS if a $500/yr syncer handles your needs.

You build a server-side integration that talks to both HubSpot's CRM API and Salesforce's REST API. Tokens stored on your side, sync logic in your code, conflict resolution by your rules.

When this is right: → Your business logic doesn't fit any connector → You're an ISV embedding HubSpot↔Salesforce sync inside your own product → You need sub-second sync (rare)

Cost: $40K-$120K to build, $5K-$15K/yr maintenance. Right for specific cases; overkill for most. See our HubSpot custom integration build guide for the build mechanics.

For each record type you'll sync, decide:

→ HubSpot to Salesforce only (marketing pushes leads to sales, sales doesn't push back) → Salesforce to HubSpot only (sales updates the master record, marketing reads) → Bidirectional (both sides write; conflict resolution required)

A common starting point that works:

Adjust based on your actual ownership model. The rule: whoever owns the record decides the direction.

For each synced object, decide which fields map across:

→ Standard fields: usually map 1:1 (firstname → FirstName, email → Email) → Custom fields: explicit decision per field; map by intent, not just by name → Picklist/enum fields: ensure the values exist on both sides → Calculated/formula fields: usually one-way only (one side computes, the other reads)

Pre-mapping discipline saves the most pain. Spreadsheet with three columns: HubSpot field, Salesforce field, sync direction. Fill it out before configuring the connector.

When both sides edit the same record before sync runs, what wins?

→ Last-modified-wins: whoever edited last. Simple. Risk: silent overwrites. → System-of-record wins: whoever owns the record always wins. Predictable. Requires per-field ownership decisions. → Field-level rules: per-field policy (email always from Salesforce, lifecycle stage always from HubSpot). Most explicit. Most config work.

The native HubSpot connector defaults to last-modified-wins. Acceptable for most teams. Move to explicit rules only when you've been burned by silent overwrites.

The actual setup steps once you've made the three decisions above:

In HubSpot: Settings → Integrations → Connected Apps → Connect an App → search "Salesforce" → install.

You'll be redirected to Salesforce to log in and authorize. Use a Salesforce account with admin permissions on the objects you want to sync.

The connector asks for default sync direction per object. Use the decisions from above. You can override per-record-type later.

For each object, map standard and custom fields. The connector pre-fills 1:1 matches by name; you adjust the custom mappings.

Decide which records sync. You can scope by: → Field values (e.g., only sync contacts with lifecycle stage = customer) → List membership (only sync contacts in HubSpot list X) → Account membership (Salesforce-side)

Most teams sync everything in v1 and add filters once they see what causes noise.

The first sync pulls all matching records from both sides and reconciles. Run it during off-hours; large account bases can take hours.

After initial sync, watch for: → Records that failed to sync (usually missing required fields) → Duplicate creation (when matching logic fails) → Picklist value mismatches

The connector's logs show all sync activity. Spend an hour reviewing them weekly for the first month.

Salesforce has Leads as a separate object from Contacts. HubSpot only has Contacts. The connector handles this by mapping HubSpot contacts to either Salesforce Leads or Contacts depending on a rule you set.

The trap: misconfigured rule sends everything to Leads, and your sales team can't find them where they expect. Decide explicitly: when does a HubSpot contact become a Salesforce Lead vs Contact?

HubSpot has a lifecycle stage value "evangelist." Salesforce doesn't. Sync fails silently or sets the field to null on the Salesforce side.

Fix: align the picklist values on both sides before syncing, or use the connector's value-mapping feature to translate.

HubSpot's "annual revenue" custom field is type number. Salesforce's mapped field is type currency. Sync rejects values or formats them wrong.

Fix: read both field definitions during mapping and adjust types or transformations to match.

Each side logs activities (calls, emails, meetings). Without bidirectional activity sync, you have to look at both systems to see a contact's full history.

Fix: enable activity sync in both directions. Accept some duplicate-looking records on one side (Salesforce will show the email as "email sent from HubSpot" and HubSpot will show it as "email logged").

A contact exists in both systems with slightly different data. Who's the master? Without explicit policy, last-edited wins and people get confused when their changes "disappear."

Fix: Decision 3 above. Document the conflict resolution policy and tell both teams how it works.

At Appnigma we generate Salesforce 2GP Managed Packages from natural-language prompts. We don't yet generate HubSpot integrations, but the underlying patterns (OAuth handling, sync direction logic, conflict resolution) transfer across ecosystems.

For an ISV that needs to embed HubSpot↔Salesforce sync inside their own product, the no-code generation future would compress the build from 3 months of custom integration work to days of prompt-driven generation. Until that future lands, custom builds remain custom. For most mid-market teams, the native HubSpot connector handles the job without any of this.

• [ ] Decided sync direction per record type → Yes / No

• [ ] Mapped fields in a spreadsheet (HubSpot field, Salesforce field, direction) → Yes / No

• [ ] Conflict resolution policy documented → Yes / No

• [ ] Picklist values aligned across both systems → Yes / No

• [ ] Lead vs Contact rule decided (when HubSpot contacts become Salesforce Leads) → Yes / No

• [ ] Activity sync direction decided → Yes / No

• [ ] Initial sync scheduled for off-hours → Yes / No

• [ ] Monitoring plan for the first 4 weeks → Yes / No

A 200-person B2B SaaS company had HubSpot for marketing and Salesforce for sales. They considered three options: native, Workato, custom build.

→ Native: free, but they worried it was "too limited" for their custom field setup. → Workato: priced at ~$25K/yr. → Custom build: scoped at ~$60K plus ongoing maintenance.

They started with the native connector as a test. Mapped 12 custom fields. Bidirectional sync on contacts and one-way sync on deals (Salesforce → HubSpot, since sales owned the pipeline). Set up explicit conflict resolution for the lifecycle stage field (HubSpot wins).

Six months later they were still on the native connector. The "too limited" concern hadn't materialized in practice. The annual savings vs Workato funded another marketing FTE. The lesson: most teams overestimate the customization they actually need.

Three options in 2026: 1/ HubSpot's native Salesforce connector (free, set up from HubSpot Settings → Integrations), 2/ Third-party Marketplace apps like Bardeen, Tray, or Workato (paid, more flexible), 3/ Custom build via Salesforce Connected App + HubSpot OAuth (expensive, deepest customization). Most mid-market teams pick the native connector. See our HubSpot integrations explained for the broader integration-type framework.

Yes. HubSpot maintains an official Salesforce connector available in HubSpot's settings → Integrations. Free with HubSpot subscription. Handles bidirectional sync of contacts, companies, deals/opportunities, leads, and activities. Custom field mapping is admin-configurable.

Limited support. Standard objects (contacts, companies, deals/opportunities, leads, activities) are supported. Custom Salesforce object sync requires the Operations Hub tier on HubSpot's side or a third-party connector.

For most mid-market teams: native connector. It handles 80% of standard use cases with no engineering investment. Custom builds are right when your business logic doesn't fit the connector's model, you're an ISV embedding the sync inside your product, or you need sub-second real-time sync. See our HubSpot custom integration guide.

HubSpot only has Contacts. Salesforce has both Leads and Contacts as separate objects. The HubSpot connector lets you set a rule for when HubSpot contacts become Salesforce Leads vs Contacts (e.g., "if lifecycle stage is SQL, create as Contact; otherwise create as Lead"). Decide this rule explicitly during setup or your sales team won't find records where they expect.

Native connector: 2-4 hours of admin configuration if your field mapping decisions are pre-made. Add 1-2 weeks of monitoring and tuning after initial sync. Custom builds: 8-12 weeks of engineering plus ongoing maintenance.

Yes, the native connector supports bidirectional activity sync. Enable it in the connector settings. Activities logged in HubSpot appear in Salesforce and vice versa. Some duplicate-looking records (e.g., "email sent from HubSpot" on the Salesforce side) are expected.

The native connector defaults to last-modified-wins (whoever edited the record last wins for any conflicting field). You can configure field-level rules for finer control (e.g., "email always sourced from Salesforce, lifecycle stage always sourced from HubSpot"). Document the policy and tell both teams.

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 Salesforce-side managed packages with proper OAuth and connector patterns; the same architectural principles guide the HubSpot↔Salesforce integration recommendations above.

Originally published June 25, 2026. Last reviewed June 25, 2026. Integration options and setup steps verified against HubSpot's Salesforce connector documentation and Salesforce Connected App security guidance current as of the published date.

• HubSpot Integrations Explained: Native, Marketplace, Custom, and Middleware

• HubSpot CRM Integrations Builder's Guide

• HubSpot Integration Providers and Services

• HubSpot Custom Integration Build Guide

• HubSpot Integration Platform Architecture Patterns

• HubSpot API Builder's Guide

• HubSpot OAuth and Scopes Complete Reference

1/ HubSpot Knowledge Base, Salesforce Integration Overview 2/ HubSpot Developers, API Documentation Overview 3/ Salesforce Help, Connected Apps Overview 4/ HubSpot Marketplace, Salesforce-related apps

Which of the three decisions did your team skip the first time, and what did it cost you in cleanup?