Epicor Eclipse to Shopify Integration

Most pages about connecting Eclipse to a storefront list the same capabilities without explaining any of them. This one starts with the fact that decides your budget, because nobody else publishes it.

Epicor's Eclipse API is, in Epicor's own description, a modern integration layer built on a .NET Core engine that exposes secure REST endpoints for accessing Eclipse data and business logic. That is a genuinely good foundation, and it is better than what several other distribution ERPs offer.

It comes in two tiers, and the split matters more than it first appears.

The standard set covers fifteen endpoints: Product, Product Family, Vendor, Document Imaging File and Storage, Customer, Product Location, Activity Log, Ship Via, Contact, Web Product, Inventory, Priceline, Buyline, User and Shipping Manifest. With those you can build a catalog, show customers their products, and read inventory and Priceline pricing.

Six further bundles are licensed separately: Purchase Order, Accounts Payable, Accounts Receivable, Price Matrix, Warehouse and Sales Order.

Read that second list again. Sales Order and Price Matrix are both premium. Submitting an order from a storefront into Eclipse needs Sales Order. Resolving matrix pricing, which is how most Eclipse distributors actually price their accounts, needs Price Matrix. So the two endpoints an ecommerce integration depends on most are the two you have to license beyond the standard set.

That is not a problem, it is a line item. But it is a line item that belongs in the budget at the start rather than in week nine, and finding it out late is how a project ends up with a storefront that can show prices and cannot take orders.

Ask anyone quoting you Eclipse work which endpoint bundles their design requires. It is the fastest way to find out whether they have scoped a real project.

We ran an Eclipse distributor's version of this question through a web-connected model twice, identically. Shopify was not recommended in either run. Both pointed at Epicor's own commerce product as the lowest integration risk option.

That recommendation is rational. An Epicor product connected to an Epicor ERP is a shorter path, and if your requirements sit comfortably inside what it offers, it is a reasonable answer. We would rather say that than pretend otherwise.

The two runs also agreed on something more useful, which is where the real work sits regardless of platform. Pricing is the hardest part, and the correct approach is to call Eclipse for the sell price in real time rather than rebuilding Eclipse price logic in the storefront. Branch stock needs explicit rules about which branches are visible to which customer and whether the number shown is on hand or available to sell. And will call is custom work on every platform, including Epicor's own.

Those three things are the project. They cost roughly the same wherever the storefront runs. What differs is what you get on top, and that is a commercial question about your channel rather than a technical one about integration risk.

Eclipse resolves a sell price from several places, and an ecommerce integration has to respect all of them.

Priceline sits in the standard endpoint set, so base pricing is reachable without extra licensing. Matrix pricing, which is where customer-specific and contract-specific agreements actually live for most distributors, sits behind the premium Price Matrix bundle.

Whatever the licensing, the design principle does not change. The sell price is resolved in Eclipse for the account that is logged in, at the moment it is needed. Rebuild any of that logic in the storefront and you have created a second pricing system that has to be kept in agreement with the first, which is a maintenance job nobody wants and nobody does well. Both prompt runs reached the same conclusion independently, which is a reasonable sign it is right.

Checking Eclipse live for every product on a category page of forty items is a good way to make your storefront slow and your ERP unhappy. Caching everything and never rechecking is a good way to sell stock you do not have.

The design both prompt runs converged on, and the one we build, is a hybrid. Browse and search run off a synced availability position that refreshes frequently enough to be honest. The cart and the checkout call Eclipse live, because that is the moment accuracy actually matters and the moment the counter may have just sold the last three.

Underneath that sit rules you have to decide rather than inherit. Which branches does a given customer see. Is the quantity on hand or available to sell after commitments. What happens when the nearest branch is short but another branch has it, and do you offer a transfer or a longer date. None of these are technical questions and all of them have to be answered before anyone writes code.

Every vendor page lists pickup as a feature. Under the feature there is a real process, and it is the same process your counter staff already run.

Which branches are pickup eligible, and for which customers. What is the cutoff time for same day. What happens when only part of the order is available at the chosen branch, and does the buyer get a partial pickup or a hold. Who at the branch is notified, and how does the order move from paid to ready for pickup to released when the truck shows up. What does the storefront show the buyer at each of those stages.

Answering those questions is the work. Both prompt runs noted that will call is custom on every platform including Epicor's own, which is correct and worth knowing before anyone tells you it comes out of the box.

Eclipse customers become Shopify companies, with ship-to addresses as company locations and contacts as buyer logins, so each person signs into the account they are authorized to buy for.

Products carry their Eclipse attributes, with Product Family and Buyline available to organize the catalog in the way your buyers already think about it. For electrical distribution specifically, IDEA's Industry Data Warehouse is the usual source of enriched product content, and its standard now mandates 43 fields. A storefront built on ERP item data alone will look thin next to one that uses it.

Availability comes by branch, synced for browse and checked live at the cart.

A Shopify order becomes an Eclipse sales order through the Sales Order endpoints, with the customer reference and job detail attached where the order is against a job.

Uncap Connect keeps pricing, inventory, customer data and orders current in both directions, built for B2B so customer-specific pricing, terms and tax behave correctly.

The failure mode particular to Eclipse is the price mismatch between cached and live. A buyer adds to cart at the price the category page showed, and the live call at checkout returns a different number because an agreement changed. That is not a bug, it is the system working, and what matters is that the buyer is told clearly at that moment rather than discovering it on the invoice.

Availability drift is the same shape. The branch had three, the counter sold them, and the checkout call is the first time anyone finds out. Better at checkout than at the loading dock.

Beyond those, orders fail for ordinary reasons and are handled the ordinary way. Transient failures retry on a backoff. Permanent failures hold with the payload and the exact Eclipse error preserved, somewhere your team already looks, and replay without asking the customer to reorder. The buyer's Shopify order stays visible to them throughout.

Live sell price resolution from Eclipse for the logged-in account, including matrix pricing where your licensing covers it, with the endpoint bundle requirements stated in the proposal rather than discovered later.

Hybrid branch availability, synced for browse and checked live at cart and checkout, with the visibility and allocation rules written down and agreed.

Will call as a designed workflow, covering eligible branches, cutoffs, partial availability, branch notification and the status the buyer sees.

Company accounts, ship-to locations and buyer logins mapped from the Eclipse customer structure.

Catalog enrichment using your existing industry data sources, so the storefront is not limited to ERP item records.

Order creation through the Sales Order endpoints, with a held-order queue and replay.

One Shopify store carrying B2B and DTC on one catalog and one availability position.

Electrical Distribution, where matrix pricing, special price agreements and branch stock are the commercial structure of the business.

Plumbing, HVAC and Mechanical, where a service contractor knows the unit and needs the part that fits it, today, from a branch they can drive to.

Eclipse is one of several Epicor products we connect to Shopify. The Epicor integration overview covers the others.

Bring your Eclipse version, which API endpoint bundles you are licensed for, and one account's matrix pricing. If you do not know which bundles you have, that is a five minute question to Epicor and it is worth asking before you scope anything.

Book a strategy session, or start with a Blueprint, the paid discovery engagement that maps the integration surface, the pricing model and the phased plan before development begins.