01 / backbone
Prophet 21 is the ledger
Multi-warehouse inventory, customer-specific contract pricing, order-to-cash. The authoritative record the distribution business is run on.
The real problem
Prophet 21 runs the warehouse. The store runs the customer.
The work is the space between: multi-warehouse inventory, contract pricing, and order-to-cash on one side, B2B buyer self-serve on the other.
02 / front door
Shopify is self-serve
Where dealers and wholesale accounts place repeat orders without a phone call, a rep, or a fax.
03 / the gap
The middle is where it breaks
Duplicate customers. Orders written twice. Prices that drift off the contract. Silent 200-on-failure writes at month-end close.
Our position
We built a product around that exact gap. Prophet 21 is the one ERP marked "path mapped" on our adapter wall: precisely understood and fully mapped against the P21 Middleware.
Prophet 21, not Kinetic
Prophet 21 is Epicor's wholesale-distribution ERP, built around multi-warehouse inventory, customer-specific contract pricing, and order-to-cash. It is not the manufacturing-oriented Epicor Kinetic (jobs, BOMs, configure-to-order, BAQ). The integration surface differs, so the ERP and version must be confirmed before scoping.
How we build it
One direction for master data. Both directions for orders.
Items, per-location stock, customers and contract pricing are read out of Prophet 21 and pushed to Shopify. The storefront never writes to the ledger. Orders are the only thing that travels both ways, and Prophet 21 stays the source of truth.
System of record
Prophet 21
read · never overwritten
The platform
Makro Middleware.
map · reconcile · audit
The storefront
Shopify Plus B2B
where buyers self-serve
Master data: Prophet 21 → Makro Middleware → Shopify, one way
Orders: Shopify → Prophet 21, status returns
P21 Middleware · one Bearer tokenOne token, minted once, works across all five APIs. The P21 Middleware exposes a REST set secured by a Bearer token from POST /api/security/token/v2; we authenticate once, cache, and reuse the session rather than re-minting it on every call and tripping the throttle.handshake
OData / Data ServicesRead-only delta reads off the P21 Middleware. Items (inv_mast) and per-location stock (inv_loc) are pulled with change detection synthesized on date_last_modified, because P21 publishes no native webhooks or CDC.P21 → MK
Inventory REST · resolved priceP21 returns a fully resolved customer-specific price in one call. GET /api/inventory/parts/{ItemId}/v2/price?customerId=… returns UnitPrice, PricePageUid and QuantityAvailable, so we resolve live and cache instead of re-implementing the pricing engine.P21 → MK
Transaction API · Interactive APIOrders aren't an Entity object, so they're written through the window-shaped Transaction Order service (oe_hdr / oe_line) or the stateful Interactive API. The Interactive API requires a real P21 username on the token for full business-logic validation.Shopify ↕ P21
Entity API · crosswalkCustomers, vendors, contacts and addresses are CRUD'd through the Entity API on the composite key {CompanyId}_{Id}. Because the Transaction API returns HTTP 200 even on a failed write, we keep a Shopify-GID ↔ P21-key crosswalk and parse Summary.Failed, not the status code.P21 ↕ MK
The console
This is not a connector. It is something you operate.
Every sync, every failure, every reconciliation is visible. This is the same Makro Middleware console your team would watch in production. Move through the views.
console.makro.agency / cedar-valley-supply / sync
live
Sync Monitor
Sync Monitor
Dead Letter Queue
Observability
Entity Key Map
Schedules
Order Relations
Records / 24h ▲
48,210
across 9 entities
Queue depth
3 pending
2 retrying · 1 review
Avg latency
1.2s
event → Shopify
Last reconcile
04:00
0 drift detected
Activitylive · last 60s
Throughputrecords / hr
In queue
3
of 48,210 processed
Auto-retrying
2
transient · session pool
Needs review
1
permanent
Resolved / 24h
41
38 auto · 3 manual
Dead Letter Queue200-on-failure never trusted blindly
| Time | Entity | Error class | Attempts | Next | Action |
|---|---|---|---|---|---|
| 08:13:04 | order · oe_hdr SO-10288 | PERMANENT · Summary.Failed | 3 / 3 | held | Inspect |
| 07:55:22 | customer · {1}_004182 | TRANSIENT · session pool | 2 / 5 | 09:50 | Retry now |
| 06:40:11 | price · ITEM-44120 | PACED · one-call pricing | 1 / 5 | paced | Inspect |
Sync volume7-day · records
Circuit breakersper endpoint
Prophet 21 · ODatalast trip · never
closedShopify · Admin APIlast trip · 3d ago
closedAvalara · AvaTaxlast trip · never
closedUptime · 90 dayserror rate 0.03%
customer · Cedar Valley Westentity_key_map
p21 key{1}_004182
canonical8f2a-c1d9-4e07-44b0
shopify gidgid://shopify/Company/61…
checksuma91f… unchanged
versionv17
→ decision: SKIP · already in sync
Every record carries three identities at once: the P21 composite key {CompanyId}_{Id}, a canonical id, and its Shopify gid. The middleware reads this row before every write and decides create, update, or skip.
P21 has no idempotency keys and uses Status:"New" for both create and update, so we dedupe on the crosswalk before re-posting. This is what stops duplicate customers and double-posted orders before they reach your ledger.
Change detection runs on the stored checksum, so a catalog of 50,000 items with 12 real edits syncs 12 records, not 50,000.
Active schedules
7
all workflows enabled
Runs today
96
0 failures
Next run
09:46
inventory levels
Nightly batch
01:00
bulk load · 48,210 records
Workflowstenant · cedar valley
Item delta syncOData · inv_mastevery 15 min✓ 09:38 · 142 recordsnext 09:53Run now
Inventory levelsQuantity Available · inv_locevery 5 min✓ 09:41 · 3 SKUsnext 09:46Run now
Contract pricingprice-page 210 / 211hourly✓ 09:00 · 1,204 rowsnext 10:00Run now
Customers & ship-tosEntity API · deltaevery 15 min✓ 09:40 · 6 recordsnext 09:55Run now
Order status returnProphet 21 → Shopifyevery 5 min✓ 09:42 · 11 ordersnext 09:47Run now
Full catalog batchbulk exportnightly · 01:00✓ 01:00 · 48,210 recordsnext 01:00Run now
Daily reconciliationboth systems vs key mapdaily · 04:00✓ 04:00 · 0 driftnext 04:00Run now
Shopify order#1042
gidgid://shopify/Order/57…
companyCedar Valley West
line 1ITEM-99320 × 12
line 2ITEM-44120 × 4
total$8,420.00
#1042↔SO-77231✓
gid://Company/88…↔{1}_004182✓
ITEM-99320 × 12↔99320 · qty 12✓
ITEM-44120 × 4↔44120 · qty 4✓
$8,420.00↔8,420.00 USD✓
entity key map · every id matched before write
Prophet 21 sales orderSO-77231
oe_hdrSO-77231
customer{1}_004182
oe_line 199320 · qty 12
oe_line 244120 · qty 4
statusconfirmed
Order journey#1042 → SO-77231 · 5s end to end
09:42:04webhook received→
09:42:04HMAC ✓ · dedup ✓→
09:42:05transformed→
09:42:06Transaction API push→
09:42:09Summary.Failed checked→
09:42:09status → Shopify
drag, scroll, or use the tabs
Inside the platform
Feature by feature.
Ten engineered subsystems sit between Prophet 21 and Shopify Plus. None of them is a setting you toggle. Each is something we built, and something your team can watch run.
01 / 10
When a record fails
Integrations are judged by how they fail. Follow one failed record.
P21's Transaction API returns HTTP 200 even on a failed write and runs on a pool of reusable sessions that can contaminate. Colour carries the verdict: amber is sorted, teal retries, red is held, green replays.
01
It arrives
A record fails to write to Shopify or Prophet 21. Instead of disappearing into a log, it enters the pipeline and gets a verdict. We inspect Summary.Failed, never the 200 status code.
→ 02
It gets classified
Every failure is sorted before anything is retried, so a bad record never loops forever. A session-pool UnexpectedResponseWindow is paced, a validation error is held.
→ 03
Transient retries
Transient and session-pool failures retry with jittered backoff, automatically, until they clear. The one-call-at-a-time pricing path is paced so it never times out at ~40-50 items in one shot.
retrying→ 04
Permanent is held
A permanent failure routes straight to the dead-letter queue for review. It is never retried blindly or lost, because P21 would have returned 200 and swallowed it otherwise.
held for review→ 05
You replay it
Fix the cause, replay from the queue against the Shopify-GID ↔ P21-key crosswalk. A daily reconciliation pass catches anything the live path missed.
replayed · reconciledThe failure modes no vendor page admits
Where pre-built Prophet 21 connectors hit a ceiling.
Prophet 21 to Shopify integrations break at predictable points. Pre-built connectors and iPaaS templates handle the happy path and flatten the distribution nuances that matter.
No native webhooks or CDC
P21 publishes no change events, so poll-based connectors lag. A 2-5 minute inventory poll oversells stock another branch already committed before the storefront catches up.
→ delta polling on date_last_modified + real-time add-to-cart check200-on-failure silent writes
The Transaction API returns HTTP 200 even when the write failed. Trust the status code and the order is silently lost at the worst possible time, during close.
→ parse Summary.Failed / Messages, never the status codeSession-pool contamination
The Transaction API runs on a pool of reusable sessions; a dirty session causes intermittent UnexpectedResponseWindow failures with no cadence. The Interactive pool defaults to 5 instances.
→ jittered retries + dedicated API user + async endpointsOne-call-at-a-time pricing
The per-item price path times out at roughly 40-50 items in one shot, and P21 publishes no hard rate limit; the throttle is architectural, governed by middleware sizing.
→ resolve live, cache, and parallelize in your own tierMulti-warehouse roll-up flattened
Connectors publish a single on-hand number. P21 stock is per inv_loc; raw on-hand oversells, and a drop-ship line should not decrement warehouse available the way a stock line does.
→ Quantity Available per location, dispositions respectedContract-price staleness
Flatten the price matrix into static Shopify lists and the contract drifts. P21's library→book→page hierarchy (types 210 / 211) resolves per logged-in customer, and a second price book in Shopify rots.
→ resolve customer-specific price live + cache, P21 single sourceClaims you can check
What you will hear, and what the Prophet 21 docs actually say.
Every reality below is verified against a primary Epicor source, a named vendor doc, or a community P21 reference. This is the difference between a team that read the marketing and a team that shipped against the documentation.
01
The claim"Epicor has a native Shopify connector, just turn it on."
The realityP21 has no out-of-the-box Shopify connector, and Epicor Commerce Connect (ECC) is built to run natively with Magento / Adobe Commerce, so it is not plug-and-play for Shopify.
02
The claim"There's one P21 API, point it at Shopify."
The realityThe surface is five overlapping APIs behind the P21 Middleware: OData / Data Services, Transaction, Interactive, Entity, and Inventory REST. No one API does it all, you compose three or more.
03
The claim"Just create the order through the Entity API."
The realityOrders aren't an Entity-API object. A Shopify order is written through the window-shaped Transaction Order service (oe_hdr / oe_line) or the stateful Interactive API.
04
The claim"If the write returns 200, the order posted."
The realityThe Transaction API returns HTTP 200 even on a failed write. You must parse Summary.Failed and Messages, because the status code lies.
05
The claim"The connector dedupes, you'll never double-post."
The realityP21 has no idempotency keys and uses Status:"New" for both create and update, so reliable dedupe requires a Shopify-GID ↔ P21-key crosswalk and a check before re-posting.
06
The claim"Read the live customer price at checkout, item by item."
The realityP21 does return a resolved customer-specific price (UnitPrice, PricePageUid, QuantityAvailable) in one call, but the pricing path is one-call-at-a-time and times out at ~40-50 items, so you resolve live and cache.
07
The claim"Contract pricing is just a price field."
The realityContract pricing is a library→book→page hierarchy (price-page types 210 Customer / 211 Customer-Item, first-match / lowest-across). Don't flatten it, and don't compute price in Shopify.
08
The claim"Sync on-hand and you're good."
The realityPublish Quantity Available (on hand − allocated) per location, never raw on-hand. "In stock" is not a stored number; stock is per inv_loc and raw on-hand oversells.
09
The claim"P21 fires webhooks like a modern API."
The realityNo native webhooks or CDC. Change detection is synthesized by the middleware with delta polling on date_last_modified and SQL change tracking.
10
The claim"P21 has a requests-per-minute rate limit you tune against."
The realityP21 publishes no hard rate-limit numbers. The throttle is architectural, governed by middleware sizing (Epicor guidance: 35-45 users per server) and licensing, and integration load competes with human users.
11
The claim"The session is fresh every time."
The realityThe Transaction API runs on a pool of reusable sessions; a dirty session causes intermittent UnexpectedResponseWindow failures with no cadence, and the Interactive pool defaults to 5 instances.
12
The claim"A customized P21 can't be integrated cleanly."
The realityDynaChange UDFs auto-flow as columns on OData reads (_ud companion tables); the Entity API needs an Enable + Regenerate step for a new UDF. Drive custom fields through DynaChange, never raw SQL columns.
13
The claim"You can stand it up without our team's involvement."
The realityIt needs a consumer key / least-privilege service account with table-scoped Dataservice Permissions, a named svc_shopify user for audit, your P21 version, and apiref.aspx confirmation.
14
The claim"A pre-built connector gives you everything a custom build does."
The realityNamed connectors are poll-based and thin on ops (B2Sell 2-5 min inventory, "real-time rarely worth it"; DCKAP / Modern Retail / iPaaS with no reconciliation or replay; InsiteConnect version-locked).
The decision guide
Four ways to connect Prophet 21 and Shopify.
There are four paths: a P21 connector vendor, an iPaaS, a custom build on the P21 Middleware, or Epicor's own ECC. Each trades control against speed, and only the custom / owned path keeps multi-warehouse inventory, customer-specific pricing, and order-to-cash intact instead of flattening them.
Option 01
P21 connector vendor
A purpose-built P21 connector such as Modern Retail or B2Sell. Faster to stand up, configured and paid for on a recurring basis.
- mappingsconfigured
- tenancymulti-tenant product
- pricingrented by the year
- inventorypoll-based · 2-5 min
Right for a distributor who wants speed over control and can live with flattened multi-warehouse and contract-pricing logic.
Option 02
iPaaS: DCKAP, Jitterbit, Celigo, Boomi, MuleSoft
Subscription middleware on a shared platform. Strong for standard multi-system sync across templated connectors.
- mappingstemplate-bound
- tenancyshared platform
- pricingannual fee
- opsno reconciliation / replay
Right for standard multi-system sync where the distribution logic fits a fixed-mapping template.
Option 03 · our build
Custom build on the P21 Middleware
Built around your exact pricing and inventory rules on the P21 Middleware + Shopify Admin API, owned by you, operated with a support agreement.
- mappingsyour fields
- tenancysingle-tenant, you keep it
- recoveryDLQ + replay + audit
- scopemulti-warehouse, contract pricing, OTC
Right for distributors who need multi-warehouse availability, customer-specific contract pricing, and order-to-cash encoded faithfully, not flattened.
Option 04 · Epicor ECC
Epicor Commerce Connect (ECC) is designed to run natively with Magento / Adobe Commerce, so for Shopify it is not plug-and-play. A pre-built connector or iPaaS is faster to stand up but is a rented, multi-tenant product you pay for on a recurring basis; a custom integration on the P21 Middleware costs more upfront but you own the asset and can encode Prophet 21's real pricing and inventory rules.
What drives timeline and cost
Driven by your data, not a contact-us wall.
A Prophet 21 to Shopify Plus build is driven by item-master readiness, data volume, custom workflows, real-time vs scheduled, and pricing-rule plus multi-warehouse complexity. The bands below are industry-reported context, not a Makro quote.
Driver 01 · readiness
item
item-master + data volume
- How clean and complete the item master is
- Volume of items, customers, ship-tos
- DynaChange UDFs and custom objects in scope
- apiref.aspx + P21 version confirmed
Driver 02 · rules
price
pricing + multi-warehouse
- Contract-pricing hierarchy depth (210 / 211)
- Multi-warehouse roll-up and dispositions
- Units of measure and UOM conversion
- Drop-ship and direct-ship handling
Driver 03 · cadence
live
real-time vs scheduled
- Real-time add-to-cart check vs scheduled sync
- Order-to-cash flow and status returns
- Tax via one Avalara account
- Phased go-live, UAT-first
Market context · not a Makro number
Industry specialists report most P21 to Shopify integrations finish in roughly 6-12 weeks with a pre-built connector and about 3-6 months for a custom build, driven mainly by pricing-rule and multi-warehouse complexity. We price a P21 integration as an engineering engagement: a build with a support agreement, not a per-record meter or a platform seat that renews forever.
Security posture
Built to pass your IT review, and your Prophet 21 administrator's questions.
Least-privilege access to Prophet 21
A Bearer token over the P21 Middleware on a consumer key (service account, Service type, table-scoped /odata:…) plus a named svc_shopify user for audit; TLS-verified, VPN / IP-allowlisted ingress.
Inbound traffic is verified
Every Shopify webhook is HMAC-verified before it is trusted, then deduplicated by event id so a replay cannot create a second order.
Everything is on the record
An append-only audit trail logs every order, inventory and pricing operation, source-tagged, so you can prove what happened during month-end close.
Credentials never in plain config
Prophet 21 and Shopify secrets are held as encrypted fields, isolated per tenant and rotatable without downtime. No credential sits in plaintext, ever.
Frequently asked questions
Where Prophet 21 integrations get hard, and where we land.
The details that separate a team that read the docs from a team that shipped against them. Open any one.
01How do you integrate Epicor Prophet 21 with Shopify?+
Four ways: a P21-specific connector vendor (Modern Retail, B2Sell), an iPaaS (DCKAP Integrator, Jitterbit, Celigo, Dell Boomi), a custom integration built on the P21 Middleware plus Shopify's Admin API, or Epicor's own ECC (which is Magento-native). For distributors who want to keep multi-warehouse inventory, customer-specific pricing, and order-to-cash logic intact, a custom integration on the P21 Middleware gives the most control.
02Does Epicor Prophet 21 have a native Shopify connector?+
No. P21 has no out-of-the-box Shopify connector, and Epicor Commerce Connect (ECC) is designed to run natively with Magento/Adobe Commerce, so it is not plug-and-play for Shopify. A reliable P21 to Shopify integration requires a purpose-built middleware platform, a custom build on the P21 Middleware, or a specialist connector vendor.
03Does Prophet 21 have an API for Shopify integration?+
Yes. P21 integrates through the P21 Middleware, which exposes a REST API set (with legacy SOAP) secured by a Bearer token. It provides several surfaces: OData/Data Services for reads, the Transaction API for bulk order and item writes, the Interactive API for reliable updates, the Entity API for customer/contact/address CRUD, and the Inventory REST API for items, per-location stock, and a resolved customer-specific price.
04How does inventory sync work between Prophet 21 and Shopify?+
It must reflect P21's multi-warehouse availability (on hand minus allocated, per location) rather than a single flattened on-hand number, so the storefront shows the right available-to-sell quantity per branch and buyers don't order stock another location has already committed. Sync is bi-directional and near-real-time, so the ERP and storefront don't drift.
05Can Prophet 21 drive Shopify Plus B2B pricing?+
Yes. Customer-specific and contract/tiered prices maintained in P21 map to Shopify Plus B2B pricing, resolved live for each logged-in dealer or wholesale account through P21's pricing engine and cached, with P21 as the single source of truth. There is no second price book to maintain in Shopify.
06What's the difference between integrating Prophet 21 versus Epicor Kinetic with Shopify?+
Prophet 21 is Epicor's wholesale-distribution ERP and Kinetic is the manufacturing ERP, so the integration is built around different objects: P21 centers on multi-warehouse inventory, customer-specific contract pricing, and order-to-cash, while Kinetic centers on jobs, BOMs, and configure-to-order. The API surfaces differ too, so the ERP and version must be confirmed before scoping.
07Should I use a connector like Modern Retail or B2Sell, an iPaaS like DCKAP, or a custom Prophet 21 integration?+
A pre-built connector or iPaaS is faster to stand up but is a rented, multi-tenant product you configure and pay for on a recurring basis, and it tends to flatten distribution nuances like multi-warehouse availability and customer-specific pricing. A custom integration on the P21 Middleware costs more upfront but you own the asset, control the data model, and can encode P21's real pricing and inventory rules.
08What happens to the integration if the P21 server goes down?+
Orders queue and retry rather than fail: P21 has no idempotency keys and its Transaction API returns HTTP 200 even on a failed write, so a custom middleware keeps a Shopify-to-P21 crosswalk, inspects the response body for failures, holds failed records in a dead-letter queue, and replays them once the cause is fixed, instead of trusting the status code and silently losing the order.
09How does contract and customer-specific pricing resolve?+
P21 returns a resolved customer-specific price through the Inventory REST call
GET /api/inventory/parts/{ItemId}/v2/price?customerId=…, which gives UnitPrice (after price-page evaluation), PricePageUid for provenance, and QuantityAvailable in one call. We resolve live and cache rather than re-implement P21's library, book and page hierarchy (price-page types 210 Customer / 211 Customer-Item), and we carry the full pricing key end to end: customerId, companyId, ship-to, and UOM with conversion.10How is multi-warehouse inventory and drop-ship handled?+
We publish Quantity Available (on hand minus allocated), per location, with the roll-up chosen on purpose, because "in stock" is not a stored number; stock is per
inv_loc and raw on-hand oversells. We also respect dispositions and drop-ship: a supplier drop-ship or direct-ship line should not decrement warehouse available the way a stock line does.11What do you need from our team to scope it?+
Three things: a consumer key or least-privilege service account with table-scoped Dataservice Permissions and a named svc_shopify user, your P21 version and confirmation against the tenant's
apiref.aspx, and your P21 administrator in the entity-mapping workshops. Master-data syncs are read-only against P21, so we are not writing to your ledger while we scope.12Are we locked into a black box, or do we own it?+
You own it. On the P21 side we use standard surfaces only: the P21 Middleware, OData / Data Services, Transaction, Interactive, Entity and Inventory REST APIs, on a Bearer token. The middleware is single-tenant and the asset is yours: your data, your field mappings, and the full audit trail are documented and exportable, unlike a shared multi-tenant connector rented by the year.
The framework underneath
A proven platform. Prophet 21 is the next first-class adapter.
Every ERP sits behind the same contract: authenticate, fetch master data, push orders, validate, report. The platform runs in production today against a live enterprise ERP. Epicor Prophet 21 is a registered target on that same framework, its path mapped to the P21 Middleware, OData, Transaction and Interactive APIs, and contract pricing.
We say this plainly: the credibility is a real platform and a precisely understood P21 path, not a decade of P21 traffic. That distinction is exactly what your architect can verify, which is why we lead with it.
adapter contractbase.ts
01authenticate()Bearer · client-credentials
02fetchMasterData()OData / Inventory REST
03pushOrder()Transaction / Interactive
04validate()Summary.Failed check
05report()audit + status
NS
NetSuite
SuiteQL · token auth · saved search
P21
Epicor Prophet 21
P21 Middleware · REST + OData · contract pricing
EK
D365 F&O · Business Central · Sage · Infor · Epicor Kinetic
REST / OData adapters
The engineering standard
Claims you can check.
$100K+ / yr
Clarius · NetSuite + Salesforce + Shopify PlusWe built a unified account page integrating Clarius' NetSuite ERP, Salesforce CRM and Shopify Plus into a single view of customer information, orders and invoices across three enterprise systems. Combined with Shopify Flow automation feeding order data into NetSuite, it eliminated manual order entry and reduced operational costs by over $100,000 a year. This is the NetSuite engagement, shown as platform credibility, not a Prophet 21 result.
1,756
Automated tests across 139 suites, run on every change.
85%
Coverage gate enforced before any deploy.
39
End-to-end browser tests across Chromium, Firefox and WebKit.
7
Failure classes, each with its own pre-decided policy.
0
Credentials stored in plaintext, anywhere, ever.
Bring your Prophet 21 administrator and your connector renewal quote. We will walk the platform, not a deck.
A real conversation about your P21 environment, your contract pricing and multi-warehouse setup, and the sharp questions you already have.