Connecting Salesforce to a Magento or Adobe Commerce store means deciding which system owns each record, mapping storefront customers and orders to Salesforce Accounts, Contacts, and Opportunities, and choosing real-time or batch sync per data type. A Hyva frontend does not change the integration itself, because the sync runs server-side against Magento’s APIs.
Most guides on this topic stop at “install a connector and pick real-time or batch.” That is the easy 20 percent. For a wholesale seller with company accounts, tiered pricing, and a sales team living in Salesforce, the hard part is deciding what is authoritative where, mapping a B2B account hierarchy that Magento and Salesforce model differently, and keeping the two systems from overwriting each other. This guide covers the parts the commodity articles skip.
Why wholesale sellers connect Salesforce to Magento
For a B2B merchant, Salesforce is where the sales team works: leads, opportunities, quotes, account notes, and forecasting. Magento or Adobe Commerce is where dealers place reorders, view contract pricing, and check order status. When those two systems are disconnected, reps quote prices the storefront does not honor, finance reconciles orders by hand, and nobody trusts the customer record.
A working integration lets a rep see a dealer’s real order history inside Salesforce, lets the storefront reflect account-level pricing negotiated in the CRM, and gives finance one clean flow from web order to booked revenue. That is the outcome. The architecture is how you get there without creating a second data mess.
Our Magento and Adobe Commerce development team has wired storefronts to CRMs and ERPs for B2B sellers since 2014, and the same pattern holds whether the frontend is legacy Luma or a modern Hyva theme build.
The three integration architectures
There are three honest ways to connect the systems. The right one depends on data volume, how much custom logic you need, and whether you already run middleware.
| Approach | Best for | Real-time capable | Custom logic | Typical cost |
|---|---|---|---|---|
| Off-the-shelf connector (Webkul, Magenest, eShopSync) | SMB and simple B2C-style catalogs | Yes, via API | Limited to the extension’s field map | Lowest |
| Middleware / iPaaS (MuleSoft, Dell Boomi, Celigo) | Enterprises with several systems already integrated | Yes | Extensive, visual orchestration | Highest ongoing |
| Custom API integration | Specific object rules a connector cannot express | Yes | Unlimited | Mid to high build, low license |
Off-the-shelf connectors are the fastest path and cover the common objects. They break down when your account hierarchy or pricing logic does not match the extension’s assumptions. Middleware earns its keep when Salesforce is one of five systems and you want one orchestration layer with error handling and replay. A custom build makes sense when the mapping rules are the whole point and you do not want to fight a connector’s opinions.
Whichever you pick, the integration should run through Magento’s asynchronous APIs and message queues rather than blocking synchronous calls, so a slow Salesforce response never stalls a checkout. Adobe documents the message queue framework in its commerce operations guide, and it is the correct backbone for any high-volume sync.
What actually maps: objects and fields
The single biggest source of confusion is object mapping, because Magento and Salesforce model people and companies differently. Magento has a customer, and in Adobe Commerce B2B a company. Salesforce splits a buyer into an Account (the company) and one or more Contacts (the people). Getting this wrong produces duplicate accounts and orphaned contacts within a week.
Here is the mapping that works for most wholesale sellers.
| Magento / Adobe Commerce | Salesforce object | Direction | Notes |
|---|---|---|---|
| Company (B2B) | Account | Usually CRM to Magento | Sales team creates the account first |
| Customer / company user | Contact | Bidirectional | Match on email to prevent duplicates |
| Order | Order or Opportunity | Magento to Salesforce | Choose one, not both |
| Product / SKU | Product2 | ERP or PIM to both | Neither should be the master |
| Quote / negotiable quote | Opportunity or Quote | Bidirectional | The B2B piece most connectors ignore |
| Invoice | Order + custom | Magento to Salesforce | Often flows via finance system |
The order-to-Opportunity versus order-to-Order decision matters. If your reps want every web order to appear as a closed-won Opportunity for forecasting, map to Opportunity. If Salesforce is only a service and account view, map to the native Order object and keep Opportunities for rep-driven deals. Mapping to both double-counts revenue and corrupts your pipeline reports.
Real-time versus batch: choose per data type, not per project
The commodity advice frames this as one global switch. It is not. Different records have different urgency, and a mature integration mixes both.
- Real-time (API or platform events): new customer registrations, order placement, order status changes, and quote submissions. These drive rep action and customer experience, so latency hurts.
- Batch (scheduled, often nightly): product catalog updates, bulk price list changes, and historical backfills. These are high volume and rarely time-sensitive to the minute.
Salesforce’s Bulk API is built for the batch side and handles large jobs without hammering your API limits, while the standard REST API and platform events handle the real-time side. Salesforce’s own data integration patterns documentation frames the same split. Running everything real-time is a common mistake that burns through Salesforce API allocations and adds no value for catalog data.
The B2B piece everyone skips: company hierarchies
This is where generic connectors fall apart. A wholesale buyer is not one person. Adobe Commerce B2B models a company with an account admin, buyers, and an approval structure. Salesforce models that as an Account with a hierarchy of Contacts and roles, and often parent-child Accounts for multi-location dealers.
You have to decide three things before writing a line of mapping code:
- Where does a company get created? For most B2B sellers, the sales team creates the Account in Salesforce during onboarding, and it flows down to Magento. The storefront should rarely be the birthplace of a company record.
- How do buyers attach to the company? Company users in Magento map to Contacts under the parent Account. Match on email, and define what happens when a buyer exists in one system but not the other.
- How does contract pricing travel? Negotiated pricing usually lives in an ERP or a price book, not the CRM. The storefront reads it so the dealer sees the right price at checkout. This is the same live-data problem as ERP integration, and we cover the storefront side of it in our guide to wiring a Hyva frontend to enterprise systems with GraphQL and API Mesh.
Skip this analysis and you get the classic failure: one dealer with three duplicate Salesforce Accounts, buyers attached to the wrong company, and pricing that does not match the quote the rep sent.
How Hyva changes the picture (and how it does not)
Merchants often assume a Hyva migration will complicate a CRM integration. It does not, because the sync is a server-side concern. Salesforce talks to Magento’s REST, GraphQL, and message queues. It has no idea whether the frontend is Luma, Hyva, or a headless React app.
What Hyva does affect is how customer-specific data renders on the storefront. Hyva fetches private, per-customer data client-side over GraphQL so the rest of the page stays inside full page cache. If you want a dealer’s Salesforce-driven account status, credit hold, or rep contact to show on the storefront, that data has to reach Magento first and then render through Hyva’s private-content pattern, not get injected into a cached block. This is the same discipline that keeps a Hyva storefront fast, and it is why the frontend and integration teams need to talk. Bemeir builds both sides, which is the point of being the first US-based Hyva Gold partner rather than a frontend-only shop.
The CRM sync itself is unchanged by the theme. If a vendor tells you a Hyva migration requires re-architecting your Salesforce integration, that is a red flag.
Idempotency, conflict resolution, and one source of truth
Three engineering rules separate an integration that lasts from one that quietly rots.
Idempotency. Every sync operation must be safe to run twice. Networks retry, queues redeliver, and a non-idempotent create turns one order into three. Use external IDs (the Magento entity ID stored on the Salesforce record, and the Salesforce ID stored on the Magento record) so an upsert matches an existing record instead of creating a new one.
Conflict resolution. When both systems change the same field, one has to win. Define per-field authority up front. A common rule: Salesforce owns account and contact details, Magento owns order and cart data, and the ERP owns pricing and inventory. Write it down, because ambiguity here is what produces the “which number is right” arguments six months in.
One source of truth per data domain. This is the governing principle. Do not let two systems both believe they own product data or customer email. Pick one master per domain and make the others read-only consumers. Bemeir’s ecosystem of 60-plus technology partners means we have integrated most of the systems that end up in this picture, and the source-of-truth map is always the first artifact we produce.
A sane implementation sequence
You do not integrate everything at once. The order that reduces risk:
- Map objects and agree source-of-truth per domain on paper.
- Sync accounts and contacts one direction first, with dedup by email and external ID.
- Add order sync (Magento to Salesforce), read-only in the CRM at first.
- Layer in quotes and B2B company structure once accounts are stable.
- Add real-time triggers only for the data that needs them.
- Build monitoring and a replay path for failed messages before you call it done.
Comparing platforms for CRM fit
If you are still choosing a commerce platform, CRM depth is part of the decision. Adobe Commerce and Magento give you the deepest B2B object model and the most integration control, which is why they suit complex Salesforce setups. A Shopify or Shopify Plus build offers a large app ecosystem with less low-level control, BigCommerce sits between the two, and Shopware is a strong option for European-rooted B2B. The sync principles in this guide apply to all of them, but the amount of custom mapping you can express is widest on Magento.
FAQ
Can I connect Salesforce to Magento without a paid extension?
Yes. Salesforce and Magento both expose full REST and Bulk APIs, so a custom or middleware integration needs no marketplace extension. A paid connector saves build time for standard objects but constrains you to its field map. For complex B2B hierarchies, a custom build or iPaaS layer is often cleaner than fighting a connector’s assumptions.
Does migrating to Hyva break my existing Salesforce integration?
No. The integration runs server-side against Magento’s APIs and message queues, which are independent of the frontend theme. A Hyva migration changes how live per-customer data renders on the storefront, not how Salesforce talks to Magento. Any vendor claiming otherwise does not understand where the integration lives.
How do I stop duplicate accounts and contacts from being created?
Use external IDs and match on email. Store the Salesforce record ID on the Magento entity and the Magento ID on the Salesforce record, then use upsert operations keyed on those IDs so a repeated sync updates the existing record instead of creating a new one. Define a single system as the birthplace for each object type.
Should orders map to Salesforce Opportunities or the Order object?
Pick one. Map to Opportunity if your reps forecast on web orders, or to the native Order object if Salesforce is purely an account and service view. Mapping to both double-counts revenue and corrupts pipeline reporting.
What if my pricing lives in an ERP, not Salesforce?
Then the ERP is the pricing source of truth, and both Magento and Salesforce read from it. This is common in wholesale. The storefront reads contract pricing so dealers see correct prices at checkout, a live-data problem we address in our work on B2B ERP, CRM, and POS integration patterns and dedicated NetSuite integration blueprints.
Getting it built
A Salesforce to Magento integration is a data-governance project wearing an engineering costume. The connectors are the easy part. The value comes from deciding what owns what, mapping a B2B hierarchy correctly, and building for idempotency and replay from day one. If you want a team that has done this on real wholesale storefronts and builds the Hyva frontend to match, talk to Bemeir.
