Acumatica is the cloud ERP that distributors and manufacturers choose when they want something modern, and it shows in the integration: Acumatica has one of the best REST APIs of any ERP in this space. But there is a specific catch that trips up companies who assumed connecting it to their store would be easy, and it is worth knowing before you plan a project. This is how an Acumatica integration with a B2B storefront actually works, and where the real work is.
The catch: Acumatica’s native connectors do not cover Magento or Shopware
Acumatica ships native commerce connectors, and they are good, but they are built for BigCommerce and Shopify. If your storefront is on one of those, the native connector does a lot for you out of the box. If you are on Magento (Adobe Commerce) or Shopware, or you want a B2B experience beyond what the native connectors deliver, you are building a real integration on Acumatica’s API rather than flipping on a packaged connector.
This matters because it is a common surprise. A distributor hears “Acumatica has ecommerce connectors” and assumes any platform is covered. For the B2B distribution scenarios we build (custom pricing, portals, complex catalogs, Magento or Shopware), the native connector is usually not the answer, and that is fine, because Acumatica’s API is genuinely good to build on. The point is to plan for a real integration, not a plugin.
The good news: Acumatica has a genuinely modern API
Where some ERPs make you fight a file-based database or a COM bridge, Acumatica gives you clean, modern ways in:
- The contract-based REST API is Acumatica’s primary, versioned REST interface. Because it is contract-based and versioned, an integration built against a contract version stays stable across Acumatica upgrades rather than breaking, which is a real operational advantage.
- Generic Inquiries (GIs) are Acumatica’s built-in mechanism for exposing custom data views, and they can be surfaced through the API. This lets an integration read exactly the data shape it needs, including custom fields, without custom server code.
- Webhooks and push let Acumatica notify the integration of changes, so inventory and pricing updates can flow more promptly than polling alone.
In practice this means an Acumatica integration can be cleaner and more real-time than integrations with older ERPs, while still following the durable pattern: read pricing and inventory into a fast layer the storefront serves from, write orders back through the API, with error handling and visibility throughout.
How an Acumatica storefront integration is built
- Connect on the contract-based REST API against a pinned contract version, so upgrades to Acumatica do not silently break the integration.
- Sync pricing and inventory, using Generic Inquiries where custom data views are needed, into a read layer the storefront serves from, refreshed on a schedule and topped up by webhooks where it helps.
- Provision customers and catalog from Acumatica, so the data stays managed where the team already works and the site stays in sync.
- Write orders back through the API, posting as sales orders with the correct customer, pricing, and warehouse, in a queue that isolates failures per order.
- Carry the distribution details that Acumatica tracks: warehouses, lot and serial numbers where relevant, and units of measure.
Acumatica specifics that shape the integration
- Price classes and customer pricing. Acumatica resolves price through customer price classes, price lists, and volume and promotional pricing. Reproducing each customer’s real price on the storefront is the core pricing task, and it is more than a single list.
- Warehouses and multiple locations. Inventory is tracked by warehouse; distributors need warehouse-level availability surfaced so buyers can see what is where.
- Lot and serial tracking. Distributors and manufacturers in regulated or traceable categories track lot and serial numbers. Where that surfaces on the storefront and in the order is a real design decision.
- Units of measure. Acumatica handles multiple units of measure with conversions (each, case, pallet), which the storefront has to price and present correctly.
- Generic Inquiries as the flexibility lever. When your Acumatica setup carries custom fields and views, GIs are how the integration reads them cleanly, which is a distinctly Acumatica way of solving the custom-data problem.
Is Acumatica a good platform to build a storefront on?
For a mid-market distributor or manufacturer, Acumatica is one of the best-positioned ERPs for a B2B storefront, because its modern, versioned API makes a stable, relatively real-time integration achievable. The honest caveat is the one this page opened with: if you are on Magento or Shopware, or you need real B2B depth, do not assume the native BigCommerce and Shopify connectors cover you. They do not, and planning for a real integration on the API is the right expectation. That is not a downside of Acumatica; it is just the correct scope.
For the storefront platform decision itself, our Magento B2B development guide and our Shopware work cover the trade-offs; the Acumatica integration underneath is built the same way either way.
What an Acumatica storefront changes
| What changes | Why | Direction |
|---|---|---|
| Order-entry labor | Orders customers place themselves stop being keyed into Acumatica by your team | Down, in proportion to phoned and emailed volume |
| Order accuracy | Orders post through the API with validated customers, pricing, and items | Fewer credits and reships |
| Data freshness | Webhooks and a versioned API keep inventory and pricing current with less lag | Fewer oversells and stale prices |
| Average order value | A buyer browsing the full, correctly priced catalog adds lines a manual order never would | Up, compounding with adoption |
How much each moves depends on how much of your Acumatica order volume is routine reorder traffic today, which an honest scoping conversation establishes before modeling a return.
Who builds this
Web Solutions NYC builds B2B commerce for distributors and manufacturers, with the ERP integration that makes it actually work. We have done this since 2007, with senior engineers in US time zones and deep experience across Epicor Prophet 21, Sage, SAP Business One, Microsoft Dynamics 365 Business Central, and Acumatica. We build on both Adobe Commerce (Magento) and Shopware, so the recommendation follows your requirements rather than our inventory. We are a Shopware Platinum Partner and an official Adobe Commerce partner.
Bring your Acumatica setup, leave with a straight answer
If you are weighing a storefront on Acumatica, the facts that decide the project are: which storefront platform you want (and whether the native connectors fit or you need a real integration), how your pricing is structured (price classes, price lists, volume pricing), and how orders reach you today. With those we can tell you what the integration really involves and where Acumatica’s API makes it lighter than you might expect. Book a Scoping Session
Frequently asked questions
Not with the native connectors. Acumatica ships native commerce connectors, but they are built for BigCommerce and Shopify. If your storefront is Magento (Adobe Commerce) or Shopware, or you need B2B depth beyond what the native connectors deliver, you build a real integration on Acumatica’s REST API rather than enabling a packaged connector. The good news is that Acumatica’s API is modern and stable, so a custom integration on it is cleaner than with many older ERPs.
Acumatica has one of the better ERP APIs for this: a contract-based, versioned REST API plus webhooks, which allows a relatively real-time integration. The durable pattern still syncs pricing and inventory into a fast read layer the storefront serves from, topped up by webhooks and refreshed on a schedule, with orders written back through the API. Because the API is contract-versioned, the integration stays stable across Acumatica upgrades instead of breaking.
It is Acumatica’s primary REST interface, and it is versioned by contract, meaning an integration is built against a specific contract version. That versioning is a real advantage: when Acumatica is upgraded, an integration pinned to a contract version keeps working rather than breaking on changed endpoints. Combined with Generic Inquiries for custom data views, it lets an integration read exactly the data it needs, including custom fields, cleanly.
Acumatica resolves price through customer price classes, price lists, and volume and promotional pricing. A correct integration maps each storefront login to its Acumatica customer and reproduces that pricing so the buyer always sees their real price. This per-customer pricing is the core of the build and, as with any distribution ERP, more layered than a single price list, which is where packaged approaches tend to fall short.
For BigCommerce and Shopify, Acumatica’s native connectors are a real option. For Magento, Shopware, or B2B requirements beyond the native connectors, you are building on the API, and Acumatica’s modern, versioned REST API makes that a clean build rather than a fight. The honest test is your storefront platform and how much custom pricing, catalog, and portal behavior you need. We build the integration where the native connectors do not reach, and we will tell you if a native connector honestly covers you.