.png)
Epicor Prophet 21 Integration Guide
Connect Epicor Prophet 21 with enterprise applications through deployment-specific REST APIs, approved file exchanges, reporting interfaces, and Martini workflows.
Epicor Prophet 21 integration options at a glance
Epicor Prophet 21 integrations commonly use REST-based APIs or P21 web-service interfaces, although endpoint catalogs, API versions, and authentication depend on the deployment and tenant. Approved file imports and exports may support structured CSV, JSON, XML, or Excel exchanges, while read-only reporting or database access can be available in selected environments. General-purpose webhooks, GraphQL APIs, and universal bulk interfaces were not verified. Martini can consume confirmed P21 endpoints, process files, invoke approved reporting interfaces, expose controlled APIs, map business objects, and orchestrate scheduled or event-driven workflows with validation, retries, and reconciliation.
| Integration point | Supported by Epicor Prophet 21? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | P21 integrations commonly use REST-based APIs or P21 web-service interfaces for Customers, Products, Inventory, Sales Orders, Purchase Orders, and Invoices. Endpoint names, operations, and API versions must be confirmed for the tenant. | Martini can consume confirmed P21 REST endpoints, map payloads, apply business rules, and orchestrate reads and writes in workflows. |
| Webhooks / outbound callbacks | Not confirmed | No general-purpose Prophet 21 webhook catalog was verified. Some customer environments may provide outbound notifications, callbacks, or event services. | If documented by the environment, Martini can receive callbacks through an exposed API endpoint or webhook workflow; otherwise scheduled polling is the conservative pattern. |
| Bulk / async / batch APIs | Not confirmed | Batch operations may exist in particular API versions or through import services, but no universal public bulk specification was verified. | Martini can implement controlled batch workflows using confirmed operations, scheduled extraction, or approved file processes. |
| File / attachment APIs | Limited | Deployment-specific import and export features may exchange structured CSV, JSON, XML, or Excel files. A general public attachment API was not verified. | Martini can parse, validate, transform, and route approved files while recording source references and processing outcomes. |
| Database / analytics access | Limited | Approved read-only reporting databases, export databases, or data warehouses may be available depending on hosting and permissions. Direct ERP database writes should not be assumed. | Martini can use approved SQL or reporting interfaces for read-oriented synchronization and analytics workflows, while preserving application APIs for writes. |
| Authentication | Limited | Credentials, tokens, required headers, permissions, and token lifetimes vary by deployment and API version. OAuth 2.0, API keys, JWTs, and scopes must not be assumed. | Martini can keep confirmed credentials in secured environment configuration and use the authentication pattern required by the P21 tenant. |
| GraphQL APIs | Not confirmed | No official Prophet 21 GraphQL API was verified in the supplied research. | Martini should use confirmed REST, file, reporting, or other supported P21 interfaces instead of assuming GraphQL availability. |
| SOAP APIs | Not confirmed | Older or deployment-specific web-service interfaces may exist, but current universal SOAP support was not verified. | Martini can consume SOAP if the customer confirms and exposes a supported interface, but new designs should not assume it. |
How Epicor Prophet 21 exposes data and business events
Epicor Prophet 21 REST APIs
Prophet 21 is commonly integrated through REST-based APIs or P21 web-service interfaces. The available resources, operations, API version, base URL, and required fields vary by deployment, tenant, licensed modules, and customer configuration.
Martini implementation pattern
Martini implementation pattern: Martini authenticates using the tenant-confirmed credential or token method, calls the required P21 resource, validates the response, maps it to a canonical model, applies business rules, and writes to or reads from the target system. Workflows persist identifiers and statuses for reconciliation.
Implementation sequence
P21 outbound notifications or callbacks
No general-purpose Prophet 21 webhook or event catalog was verified. A particular environment may expose outbound notifications, callbacks, or event services, but coverage for Customers, Products, Inventory, Sales Orders, Purchase Orders, and Invoices must be confirmed.
Martini implementation pattern
Martini implementation pattern: when a documented callback exists, Martini exposes a controlled API endpoint, authenticates or validates the notification, retrieves the current P21 object if necessary, and processes it idempotently. When callbacks are unavailable, the equivalent workflow uses scheduled incremental polling.
Implementation sequence
Prophet 21 files and reporting interfaces
Some deployments may provide file imports, exports, reporting databases, or approved read-only database access. These mechanisms are deployment-specific, and direct writes to the ERP database should not replace supported application APIs or imports.
Martini implementation pattern
Martini implementation pattern: Martini retrieves an approved file or reporting result, validates its structure and provenance, converts it into a canonical model, and routes the result to downstream systems. File and SQL workflows should be isolated from write operations that require P21 application validation.
Implementation sequence
Common Epicor Prophet 21 integration patterns
Pattern 1: Create sales orders from commerce channels
When to use this pattern
Use this pattern when an online or customer-facing application must create Prophet 21 Sales Orders. The workflow resolves Customers and Products, validates warehouse, pricing, shipping, and payment-related fields, and prevents duplicate creation when the source retries a request.
Integration direction
Example Mapping
| Epicor Prophet 21 Field | Canonical Field | Target Field |
|---|---|---|
| Shopify order_id | externalOrderId | Sales Order external reference |
| Shopify customer_id | customerId | Customer identifier |
| Shopify line_items[].sku | productCode | Product / Item identifier |
| Shopify line_items[].quantity | orderedQuantity | Sales Order line quantity |
Martini implementation pattern
Martini receives the order request or event, checks the stable source order identifier, retrieves or resolves the P21 Customer and Product identifiers, validates business rules, and submits the Sales Order through the confirmed API. A response mapping returns the P21 order number; ambiguous timeouts trigger a lookup before retrying.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Publish warehouse inventory availability
When to use this pattern
Use this pattern when commerce, marketplace, or customer-facing systems need current P21 availability. The workflow should distinguish on-hand, allocated, committed, and available quantities and apply warehouse, safety-stock, and unit-of-measure rules.
Integration direction
Example Mapping
| Epicor Prophet 21 Field | Canonical Field | Target Field |
|---|---|---|
| Inventory.product_id | productCode | Shopify SKU |
| Inventory.warehouse_id | warehouseCode | Location |
| Inventory.available_quantity | availableQuantity | Inventory level |
| Inventory.modified_time | lastChangedAt | Synchronization timestamp |
Martini implementation pattern
A scheduled Martini workflow retrieves filtered or incrementally changed Inventory records, aggregates or selects warehouse quantities according to business rules, converts units where required, and publishes the normalized result. Failed updates are retried without reprocessing unchanged inventory, and discrepancies are sent to reconciliation.
Martini capabilities used
- scheduling workflows
- API consumption
- data mapping
- transformations
- monitoring
Pattern 3: Synchronize customers and invoices
When to use this pattern
Use this pattern when finance, CRM, support, or reporting applications require governed P21 customer and billing data. P21 identifiers remain available for reconciliation while downstream models receive normalized fields.
Integration direction
Example Mapping
| Epicor Prophet 21 Field | Canonical Field | Target Field |
|---|---|---|
| Customers.customer_number | customerExternalId | Salesforce Account external ID |
| Customers.account_status | accountStatus | Account status |
| Invoices.invoice_number | invoiceNumber | Invoice reference |
| Invoices.total_amount | invoiceTotal | Invoice amount |
Martini implementation pattern
Martini polls or consumes an approved export, retrieves Customers and Invoices, validates dates and decimal values, maps the objects to the target model, and applies ownership and status rules. The workflow records source and target identifiers, isolates business validation errors, and retries transient delivery failures.
Martini capabilities used
- workflows
- scheduled synchronization
- data mapping
- validation
- error handling
Pattern 4: Exchange purchase orders and supplier updates
When to use this pattern
Use this pattern when supplier portals, SPS Commerce, or warehouse platforms must exchange purchasing documents and expected receipts with P21. The exact create and update operations must be confirmed for the customer environment.
Integration direction
Example Mapping
| Epicor Prophet 21 Field | Canonical Field | Target Field |
|---|---|---|
| Partner purchaseOrderNumber | sourcePurchaseOrderId | Purchase Order reference |
| Partner itemCode | productCode | Product / Item identifier |
| Partner requestedQuantity | orderedQuantity | Purchase Order line quantity |
| Partner expectedDate | expectedReceiptDate | Expected receipt date |
Martini implementation pattern
Martini receives a confirmed partner API response or file, validates supplier and item references, maps the document to the P21 Purchase Order structure, and submits it through the enabled interface. Correlation keys prevent duplicate orders, while partial line failures and supplier-status conflicts are routed for review.
Martini capabilities used
- file processing
- API consumption
- data mapping
- business rules
- reconciliation
Applications commonly integrated with Epicor Prophet 21
Epicor Prophet 21 commonly sits at the center of distribution operations, so integrations typically connect its customer, product, inventory, order, purchasing, and invoicing data with adjacent commerce, CRM, service, tax, and trading-partner applications. The exact ownership of each data domain should be confirmed for the organization.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Publish product and inventory availability to online channels and create Prophet 21 Sales Orders from online purchases. | Shopify → Martini → Epicor Prophet 21 | Martini receives Shopify order data, resolves P21 Customers and Products, validates warehouse and pricing information, creates a Sales Order through the confirmed P21 API, and returns the P21 identifier. Scheduled workflows can publish normalized inventory back to Shopify. |
| Salesforce | Synchronize customer accounts, contacts, order history, product information, and account status across sales and distribution operations. | Epicor Prophet 21 → Martini → Salesforce | A Martini workflow retrieves Customers, Products, and selected Sales Orders from P21, maps them to Salesforce objects, preserves source identifiers, and applies ownership and update rules. Salesforce-originated changes can be routed back when the P21 API exposes the required operations. |
| NetSuite | Coordinate selected financial, order, product, or customer information when both platforms operate across business units. | Epicor Prophet 21 → Martini → NetSuite | Martini uses domain-specific workflows to retrieve P21 objects, transform financial and operational fields into NetSuite structures, and reconcile identifiers and statuses. Bidirectional processing is used only where ownership and supported endpoints are defined. |
| ServiceNow | Provide service-management workflows with customer, order, fulfillment, and exception context. | Epicor Prophet 21 → Martini → ServiceNow | Martini retrieves relevant P21 Customers, Sales Orders, and status information, applies exception rules, and creates or updates ServiceNow records. Selected service status changes can be returned to P21 when supported by the configured API. |
| Zendesk | Give support agents customer, order, shipment, and invoice context without requiring direct ERP access. | Epicor Prophet 21 → Martini → Zendesk | A scheduled or API-triggered Martini workflow reads P21 Customers, Sales Orders, and Invoices, maps approved fields to Zendesk, and retains P21 identifiers for support lookups and reconciliation. |
| Microsoft Dynamics 365 | Synchronize customer, product, order, or financial information in organizations operating both platforms. | Epicor Prophet 21 → Martini → Microsoft Dynamics 365 | Martini orchestrates domain-specific synchronization, normalizes customer and product keys, applies system-of-record rules, and handles validation or retry outcomes separately for each object type. |
| SPS Commerce | Exchange purchase orders, acknowledgments, advance shipping notices, and invoices with trading partners. | SPS Commerce → Martini → Epicor Prophet 21 | Martini consumes the applicable SPS interfaces or files, validates partner and item references, maps documents to P21 Purchase Orders or Invoices where supported, and records correlation identifiers for reconciliation. |
| Avalara | Send transaction data for tax calculation and return tax results for sales-order or invoicing processes. | Epicor Prophet 21 → Martini → Avalara | Martini maps P21 customer, product, address, and transaction data to Avalara requests, validates the response, and routes tax results into the relevant order or invoice workflow when the configured P21 operations permit it. |
How to build a Epicor Prophet 21 integration in Martini
Objective
Establish the P21 endpoint, deployment context, permissions, and authentication behavior before designing object workflows.
Instructions in Martini
- Confirm the P21 version, hosting model, API base URL, and enabled modules.
- Obtain a least-privilege integration identity and separate test and production credentials.
- Store credentials and tokens in secured Martini environment configuration.
- Confirm required headers, token expiry, network restrictions, and permissions.
Objective
Select the trigger that matches the confirmed P21 capability and synchronization requirement.
Instructions in Martini
- Use a Martini API endpoint for inbound commerce or application requests.
- Use a webhook workflow only when the P21 environment documents the required callback.
- Use a scheduler and incremental query for conservative polling-based synchronization.
- Define the checkpoint, modified-time window, or source file boundary.
Objective
Bring P21 data or approved files into the workflow while preserving source identifiers and request context.
Instructions in Martini
- Call the confirmed P21 resource or receive the approved file or notification.
- Handle pagination, filtering, continuation tokens, and page-size limits explicitly.
- Capture P21 identifiers, source identifiers, timestamps, and response status.
- Treat ambiguous timeouts as reconciliation cases before retrying creates.
Objective
Coordinate lookups, validation, transformations, target writes, and exception routes as a maintainable Martini workflow.
Instructions in Martini
- Resolve Customers, Products / Items, warehouses, suppliers, and other required references.
- Sequence dependent operations and use conditional branches for business outcomes.
- Separate transient technical failures from P21 validation or permission failures.
- Use reusable workflow logic for common authentication, lookup, and reconciliation behavior.
Objective
Convert P21-specific structures into canonical and target-specific models without losing identifiers or precision.
Instructions in Martini
- Map actual P21 object fields to the target application model.
- Preserve decimal precision for prices, quantities, tax, discounts, and currency values.
- Normalize dates, time zones, units of measure, statuses, and address structures.
- Retain original P21 and source-system identifiers for traceability.
Objective
Ensure integration behavior respects P21 validation, credit, warehouse, pricing, tax, and status rules.
Instructions in Martini
- Validate required customer, product, warehouse, supplier, and document references.
- Apply safety-stock, availability, ownership, and system-of-record rules.
- Route rejected business transactions separately from technical failures.
- Check for existing Sales Orders, Purchase Orders, or Invoices before retrying creates.
Common Epicor Prophet 21 data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Customers | Synchronize customer accounts, addresses, contacts, credit information, and account status. | Salesforce, Zendesk, Shopify, Microsoft Dynamics 365, reporting platforms | Martini retrieves or receives confirmed P21 payloads, maps identifiers and address structures, validates required fields, and preserves P21 keys for reconciliation. |
| Products / Items | Distribute product identifiers, descriptions, units of measure, pricing, and purchasing information. | Shopify, Microsoft Dynamics 365, Salesforce, SPS Commerce | Martini normalizes product and unit-of-measure data, applies publication rules, and routes only approved product fields to downstream systems. |
| Inventory | Share on-hand, available, allocated, committed, and warehouse-level quantities. | Shopify, marketplaces, warehouse platforms, reporting systems | Scheduled Martini workflows retrieve filtered inventory, apply safety-stock and availability rules, convert units where required, and publish a consistent availability model. |
| Sales Orders | Create and track customer orders, lines, pricing, shipping details, and order status. | Shopify, Salesforce, ServiceNow, Avalara, fulfillment platforms | Martini validates customer and product references, applies pricing and warehouse rules, submits supported operations, and uses stable source identifiers to prevent duplicates. |
| Purchase Orders | Exchange supplier orders, lines, expected receipts, and purchasing status. | SPS Commerce, supplier portals, procurement applications, warehouse platforms | Martini maps supplier and item identifiers, processes acknowledgments or status updates where supported, and records correlation data for reconciliation. |
| Invoices | Distribute billing documents, charges, payments, and accounts-receivable information. | NetSuite, Microsoft Dynamics 365, Avalara, Salesforce, reporting systems | Martini transforms invoice and tax fields, preserves document identifiers, validates numeric precision, and routes business validation failures for review. |
Authentication and security considerations
Deployment-specific authentication
Prophet 21 authentication depends on the deployment, API version, tenant configuration, and licensed capabilities. Do not assume OAuth 2.0, API keys, JWTs, scopes, or a universal token endpoint without tenant documentation.
Least-privilege access
- Use a dedicated integration identity with only the permissions required by each workflow.
- Separate development, test, and production credentials.
- Confirm token expiration, required headers, IP restrictions, and network access.
Secure Martini configuration
Martini should keep P21 credentials and tokens in secured environment configuration or secrets-management facilities rather than workflow mappings or source code. Use HTTPS/TLS for API communication and expose only controlled downstream APIs.
Operational considerations for Epicor Prophet 21 integrations
API behavior
- Confirm pagination, filtering, page limits, rate limits, concurrency limits, and throttling behavior.
- Use incremental queries for Customers, Products, Inventory, Sales Orders, Purchase Orders, and Invoices where supported.
- Use controlled concurrency and retry backoff for transient failures.
Data integrity
- Use stable external references to prevent duplicate Sales Orders, Purchase Orders, and Invoices.
- Preserve decimal precision, currency, dates, time zones, units of measure, and warehouse context.
- Treat P21 validation responses as business outcomes and route them separately from transport errors.
Change management
P21 versions, customizations, modules, and tenant settings can change fields, required values, and status behavior. Test mappings against representative data, monitor schema and enumeration changes, and maintain reconciliation workflows for partial failures and missed updates.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini centralizes API calls, approved file processing, validation, transformations, business rules, and target-system writes in maintainable workflows. This avoids duplicating P21 authentication and mapping logic across point-to-point scripts.
Controlled integration contracts
Martini can expose stable APIs to downstream applications while keeping P21 endpoint details and credentials inside the integration layer. It can also create reusable assets from confirmed external API definitions and support scheduled, API-led, and event-oriented processing where the environment permits it.
Operational visibility
- Capture source and target identifiers, checkpoints, request timestamps, and response outcomes.
- Separate retryable failures from business validation errors.
- Support monitoring, troubleshooting, and reconciliation as part of the workflow design.
Frequently asked questions
Prophet 21 can be integrated through deployment-specific REST APIs or P21 web-service interfaces, and in some environments through approved file imports, exports, callbacks, or read-only reporting interfaces. API versions, endpoint availability, authentication, and licensed capabilities must be confirmed for the specific tenant.
Yes. Martini can consume a confirmed Prophet 21 REST API, process approved files or reporting interfaces, and orchestrate workflows that map Customers, Products, Inventory, Sales Orders, Purchase Orders, and Invoices. A dedicated native Martini connector was not verified in the supplied research.
No. A dedicated Prophet 21 connector is not required. Martini can use the customer environment's confirmed REST APIs, approved file interfaces, callbacks, authentication methods, or reporting endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Prophet 21. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Epicor, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
For new integrations, use the tenant-confirmed REST API or P21 web-service interface where supported. Approved file imports or exports and read-only reporting interfaces can support selected use cases. GraphQL was not verified, and universal SOAP or bulk API support should not be assumed.
A general-purpose webhook framework covering all P21 business objects was not verified. If a specific environment exposes outbound notifications, callbacks, or event services, Martini can receive them; otherwise scheduled polling with incremental filters is the more conservative pattern.
Martini can retrieve or receive P21 data, map it to a canonical or target-specific model, transform dates, numbers, units, statuses, and addresses, apply business rules, and write to downstream applications. Stable source and P21 identifiers support incremental synchronization and reconciliation.
Workflows can distinguish transient transport failures from P21 validation, permission, and business-rule errors. Retries should use controlled backoff, while create operations should check stable external references and query for accepted transactions before retrying. Checkpoints, statuses, and reconciliation data should be persisted.
Yes. Martini can expose a controlled API that hides tenant-specific P21 credentials and endpoint details from downstream applications. The façade can validate requests, orchestrate P21 lookups and writes, apply business rules, and return a stable contract to consumers.
Related Martini documentation
API integration
Data processing
Plan your Epicor Prophet 21 integration
Use Martini to connect confirmed Prophet 21 APIs, approved file interfaces, and reporting endpoints with the applications that support your distribution operations.