.png)
Shopify Plus Integration Guide
Connect Shopify Plus with enterprise applications through Shopify’s GraphQL and REST APIs, webhooks, bulk operations, and secure app authentication.
Shopify Plus integration options at a glance
Shopify Plus integrations use Shopify’s shared platform APIs rather than a separate Shopify Plus API. For new administrative integrations, the GraphQL Admin API is the primary option for products, orders, customers, inventory, fulfillment, metafields, and related resources; REST remains relevant for legacy applications and selected operations. Shopify also supports HTTPS webhooks for selected topics, asynchronous GraphQL bulk operations, file and staged-upload operations, and Storefront or Customer Account APIs for supported experiences. Martini can consume these APIs, receive and validate webhook notifications, orchestrate scheduled reconciliation workflows, map data to enterprise systems, and securely manage tokens, scopes, and signing secrets.
| Integration point | Supported by Shopify Plus? | Common use cases | How Martini supports it |
|---|---|---|---|
| GraphQL APIs | Yes | The GraphQL Admin API supports products, orders, customers, inventory, fulfillment, metafields, files, and other administrative resources. Storefront and Customer Account APIs support selected customer-facing experiences. | Martini can consume GraphQL operations, map nested responses, control selected fields, paginate connections, and orchestrate the results in workflows. |
| REST APIs | Legacy | Shopify Admin REST APIs remain relevant to existing applications and selected resource operations, although Shopify recommends GraphQL for new public app development. | Martini can consume Shopify REST endpoints where an existing integration or required operation depends on REST, with configured authentication, pagination, and error handling. |
| Webhooks | Yes | HTTPS webhook topics include orders, products, customers, inventory levels, fulfillments, and app uninstallation. Coverage is topic-specific rather than universal. | Martini can receive webhook requests, verify Shopify HMAC signatures, acknowledge promptly, and hand longer processing to asynchronous workflows with idempotency controls. |
| Bulk and asynchronous APIs | Yes | GraphQL bulk operations support large queries and selected mutations for initial catalog loads, historical orders, customer extraction, inventory reconciliation, and large updates. | Martini can submit operations, track status, retrieve result files, process JSON Lines data, and persist operation identifiers and checkpoints. |
| File and attachment APIs | Yes | Shopify file operations and staged uploads support product media, store files, images, videos, and documents associated with supported resources. | Martini can orchestrate upload and association workflows, handle asynchronous processing states, and map file results to supported Shopify resources. |
| Authentication | Yes | Shopify supports OAuth-based app authorization, Admin API access tokens, API scopes, Storefront tokens, and selected client-credentials scenarios. Webhooks require HMAC verification. | Martini can keep tokens, client secrets, scopes, signing secrets, and store-specific settings in secure environment configuration. |
| Database access | No | Shopify does not expose direct merchant database access. Supported integration routes are APIs, webhooks, bulk operations, and file mechanisms. | Martini can connect to enterprise databases separately, while Shopify data is exchanged through its supported APIs and event mechanisms. |
How Shopify Plus exposes data and business events
Shopify GraphQL APIs
Shopify’s GraphQL Admin API is the primary current administrative API for products, orders, customers, inventory, fulfillment, metafields, files, and other resources. The Storefront API and Customer Account API support selected customer-facing experiences.
Martini implementation pattern
Martini implementation pattern: Martini consumes the required GraphQL operation from a workflow, supplies store-specific authentication, controls the requested fields, follows cursor-based pagination, and transforms nested responses into canonical or target-system models.
Implementation sequence
Shopify REST APIs
Shopify Admin REST APIs remain available for existing applications and selected operations, but Shopify identifies the REST Admin API as legacy for new public app development.
Martini implementation pattern
Martini implementation pattern: Martini consumes the required REST endpoint when an existing integration or resource operation depends on it, handles response pagination and throttling, and keeps the REST implementation isolated so it can be migrated to GraphQL when appropriate.
Implementation sequence
Shopify Webhooks
Shopify supports HTTPS webhook subscriptions for selected topics such as order, product, customer, inventory, fulfillment, and app lifecycle events. Webhook coverage is topic-specific and is not a universal change feed.
Martini implementation pattern
Martini implementation pattern: Martini exposes a webhook-driven entry point, verifies the Shopify HMAC signature, acknowledges promptly, records an event or resource key, and invokes an asynchronous workflow to retrieve authoritative data and update downstream systems.
Implementation sequence
Shopify Bulk Operations
Shopify GraphQL bulk operations provide asynchronous processing for large queries and selected mutations, including catalog loads, historical orders, customer extraction, and reconciliation tasks.
Martini implementation pattern
Martini implementation pattern: Martini submits a bulk operation, stores its identifier, tracks status through polling or configured completion notification, retrieves the result file, processes JSON Lines incrementally, and records checkpoints to make retries safe.
Implementation sequence
Shopify File Operations
Shopify provides file and media operations, including staged uploads, for product media, store files, images, videos, and documents associated with supported resources. It is not a universal attachment model for every resource.
Martini implementation pattern
Martini implementation pattern: Martini coordinates staged upload or file operations, waits for asynchronous processing where necessary, validates the resulting file state, and associates the file with the intended Shopify resource or downstream repository.
Implementation sequence
Common Shopify Plus integration patterns
Pattern 1: Sync products and inventory to an ERP
When to use this pattern
Use this pattern for initial catalog loads, scheduled product synchronization, or ongoing inventory alignment between Shopify Plus and an ERP such as NetSuite. Large catalogs should use GraphQL bulk operations, while smaller changes can use webhooks and targeted reads.
Integration direction
Example Mapping
| Shopify Plus Field | Canonical Field | Target Field |
|---|---|---|
| Product.id | product.externalId | NetSuite item external ID |
| Product.title | product.name | item display name |
| ProductVariant.sku | product.sku | item SKU |
| InventoryLevel.available | inventory.availableQuantity | location quantity |
Martini implementation pattern
A scheduled Martini workflow submits a Shopify GraphQL query or bulk operation, follows pagination or processes the result file, maps Products, variants, locations, and Inventory levels, and applies field ownership rules before writing NetSuite. The workflow records checkpoints, throttles requests, and retries transient failures without duplicating updates.
Martini capabilities used
- scheduled workflows
- GraphQL API consumption
- bulk processing
- data mapping
- business rules
- error handling
Pattern 2: Route Shopify orders to fulfillment and ERP systems
When to use this pattern
Use this pattern when Shopify order events must create downstream sales orders, tax requests, or fulfillment work. It combines event-driven processing with an authoritative API read because webhook payloads may not contain every field required downstream.
Integration direction
Example Mapping
| Shopify Plus Field | Canonical Field | Target Field |
|---|---|---|
| Order.id | order.externalId | sales order external ID |
| Order.lineItems | order.lines | sales order lines |
| Order.shippingAddress | shipping.address | ship-to address |
| FulfillmentOrder.status | fulfillment.status | shipment status |
Martini implementation pattern
Martini receives and verifies an order webhook, checks the Shopify order ID or event key for prior processing, retrieves complete order and fulfillment data through GraphQL, and routes mapped data to NetSuite or ShipStation. Validation, idempotency, bounded retries, and reconciliation handle duplicate, delayed, or out-of-order delivery.
Martini capabilities used
- webhook consumption
- workflow orchestration
- API consumption
- data mapping
- idempotency controls
- retry and error handling
Pattern 3: Synchronize customers and purchase activity to engagement systems
When to use this pattern
Use this pattern when approved Shopify customer, consent, and order activity must be available in Salesforce or Klaviyo for service, segmentation, or lifecycle marketing. Customer-data permissions and field-level ownership should be established before activation.
Integration direction
Example Mapping
| Shopify Plus Field | Canonical Field | Target Field |
|---|---|---|
| Customer.id | customer.externalId | contact or profile external ID |
| Customer.email | customer.email | contact email |
| Customer.tags | customer.segments | profile segments |
| Order.totalPriceSet | purchase.total | event revenue |
Martini implementation pattern
Martini consumes selected customer and order webhooks, retrieves current Shopify details when needed, filters sensitive and non-approved fields, and transforms the result into Salesforce or Klaviyo payloads. A durable event key prevents duplicate activity, while consent rules determine whether profile or marketing data may be sent.
Martini capabilities used
- webhook-driven workflows
- data filtering
- mapping and transformation
- business rules
- secure configuration
- duplicate handling
Pattern 4: Reconcile Shopify data with external commerce channels
When to use this pattern
Use this pattern when Shopify Plus participates in a multi-channel catalog and order model involving Amazon or Google Merchant Center. It is useful for scheduled recovery, inventory correction, and enforcing ownership when multiple systems can change commercial data.
Integration direction
Example Mapping
| Shopify Plus Field | Canonical Field | Target Field |
|---|---|---|
| ProductVariant.barcode | catalog.globalTradeItemNumber | channel product identifier |
| ProductVariant.price | catalog sellingPrice | channel price |
| InventoryLevel.available | catalog.availableQuantity | channel availability |
| Order.lineItems | channelOrder.lines | order intake lines |
Martini implementation pattern
A scheduled Martini workflow retrieves products, variants, and inventory through paginated GraphQL queries or bulk operations, normalizes channel-specific fields, and publishes approved data. Incoming channel orders can be routed through a separate workflow, with ownership rules, reconciliation checkpoints, and retry handling preventing competing updates.
Martini capabilities used
- scheduled synchronization
- bulk operations
- data normalization
- field ownership rules
- workflow orchestration
- monitoring and error handling
Applications commonly integrated with Shopify Plus
Shopify Plus commonly participates in multi-system commerce architectures. Martini can coordinate Shopify APIs and webhooks with named enterprise applications while applying field-level ownership, validation, retries, and transformation rules.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| NetSuite | Synchronize products, inventory, customers, orders, fulfillment, and financial data between Shopify commerce operations and ERP processes. | Shopify Plus → Martini → NetSuite | Use Shopify webhooks for order changes and scheduled or bulk GraphQL workflows for catalog and inventory synchronization. Map Shopify objects into NetSuite sales orders and item structures, enforce idempotency, and route failures for retry or review. |
| Salesforce | Align Shopify customers and purchase activity with CRM, service, loyalty, and customer engagement processes. | Shopify Plus → Martini → Salesforce | Receive selected customer and order events, retrieve complete Shopify data through GraphQL, normalize consent and profile fields, and publish approved updates to Salesforce while applying customer-data access controls. |
| Klaviyo | Send customer, catalog, and order events to support segmentation and lifecycle marketing. | Shopify Plus → Martini → Klaviyo | Transform Shopify customer, product, and order events into Klaviyo profile and event payloads, deduplicate deliveries, and restrict synchronization to approved marketing and consent attributes. |
| ShipStation | Route Shopify orders into shipping workflows and return tracking, shipment, and fulfillment status to Shopify. | Shopify Plus → Martini → ShipStation | Trigger on eligible Shopify orders, map line items and addresses to ShipStation, then consume shipment results and update Shopify fulfillment status and tracking with duplicate protection. |
| Avalara | Exchange tax-related transaction information and tax results between commerce or order workflows and tax services. | Shopify Plus → Martini → Avalara | Orchestrate tax requests from order workflows, map Shopify addresses and line items to Avalara inputs, validate returned tax values, and persist the outcome for downstream order or finance processing. |
| Zendesk | Provide support agents with customer, order, fulfillment, and return context. | Shopify Plus → Martini → Zendesk | Expose a normalized Martini API or push selected Shopify customer and order data to Zendesk, applying privacy filters and lookup rules so support context remains current without exposing unnecessary fields. |
| Google Merchant Center | Publish product, availability, and catalog information for shopping listings and advertising. | Shopify Plus → Martini → Google Merchant Center | Use scheduled GraphQL reads or product webhooks to normalize products, variants, prices, and inventory, then transform the approved catalog model for Google Merchant Center exchange. |
| Amazon | Coordinate catalog, inventory, and order flows for a multi-channel commerce operation. | Shopify Plus → Martini → Amazon | Define ownership by field, normalize Shopify products and inventory for outbound marketplace flows, and route marketplace order data through Martini to Shopify or the enterprise order-management process with reconciliation checkpoints. |
How to build a Shopify Plus integration in Martini
Objective
Establish Shopify access using the app authorization model, token type, scopes, store domain, and webhook signing secret required for the integration.
Instructions in Martini
- Configure Shopify OAuth or access-token settings for the selected app model
- Request only the Admin API scopes required by the workflow
- Store tokens, client secrets, store identifiers, and signing secrets in Martini secure configuration
- Separate credentials and store settings by environment and Shopify store
Objective
Select an event-driven, scheduled, API-led, or bulk-operation trigger based on the data volume and freshness requirements.
Instructions in Martini
- Use Shopify HTTPS webhooks for supported topics
- Use a scheduler for reconciliation and incremental reads
- Use GraphQL bulk operations for large initial or historical loads
- Use an exposed Martini API when downstream systems need normalized Shopify data
Objective
Obtain an event notification and retrieve authoritative Shopify data through GraphQL or REST when the webhook payload is incomplete.
Instructions in Martini
- Verify Shopify webhook HMAC signatures before trusting payloads
- Acknowledge webhook requests promptly
- Follow GraphQL cursors and handle REST pagination where applicable
- Track bulk-operation identifiers and completion status
Objective
Coordinate Shopify calls, target-system calls, enrichment, validation, and persistence in a maintainable Martini workflow.
Instructions in Martini
- Separate intake, retrieval, transformation, and delivery stages
- Use asynchronous processing for long-running webhook work
- Persist event keys, resource identifiers, and processing checkpoints
- Apply bounded retries for transient API or downstream failures
Objective
Convert Shopify Products, variants, Orders, Customers, Inventory levels, and Fulfillment orders into canonical and target-specific models.
Instructions in Martini
- Map identifiers, monetary values, addresses, statuses, and timestamps explicitly
- Normalize nested GraphQL responses and JSON Lines bulk results
- Filter customer and order fields according to permissions and business need
- Handle metafields through documented namespace, key, type, and ownership rules
Objective
Enforce system-of-record decisions, validation, consent, idempotency, and multi-store or market-specific behavior before writing data.
Instructions in Martini
- Define ownership for prices, catalog fields, inventory, customers, orders, fulfillment, and metafields
- Validate required fields and reject or quarantine invalid messages
- Use Shopify event IDs, resource IDs, or composite keys for duplicate protection
- Include store, market, currency, location, and regional context where relevant
Common Shopify Plus data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Products | Synchronize catalog descriptions, status, vendor data, options, and product-level attributes. | NetSuite, Google Merchant Center, Amazon, Salesforce | Martini retrieves Products through GraphQL or REST, maps them to a canonical catalog model, applies ownership rules, and processes large loads through bulk operations. |
| Product variants | Exchange sellable SKUs, prices, barcodes, option values, and inventory identifiers. | NetSuite, Amazon, Google Merchant Center, fulfillment platforms | Martini maps variant identifiers and commercial attributes, validates required SKU and price fields, and associates variants with Products and Inventory levels. |
| Orders | Transfer purchases, line items, financial status, addresses, discounts, shipping, and transaction information. | NetSuite, Avalara, ShipStation, Salesforce, Zendesk | Martini receives selected order webhooks, retrieves complete order details, applies idempotency, maps line items and addresses, and routes failures for retry. |
| Customers | Synchronize profiles, addresses, tags, order history references, and marketing consent. | Salesforce, Klaviyo, Zendesk, NetSuite | Martini filters sensitive fields and scopes, maps customer identifiers and consent values, and synchronizes only approved attributes. |
| Inventory levels | Represent quantity for an inventory item at a specific Shopify location. | NetSuite, Amazon, Google Merchant Center, ShipStation | Martini combines inventory identifiers, locations, and quantities, applies ownership and concurrency rules, and uses scheduled reconciliation alongside inventory webhooks. |
| Fulfillment orders | Represent fulfillment work assigned to locations or fulfillment services, including status and line items. | ShipStation, NetSuite, warehouse and fulfillment applications | Martini maps fulfillment assignments and status transitions, updates tracking where supported, and prevents duplicate fulfillment writes. |
Authentication and security considerations
Authentication and security
Shopify integrations commonly use OAuth-based app authorization, Admin API access tokens, Storefront API tokens, and API scopes. The selected token and scopes depend on the app type and data being accessed.
- Store tokens, client secrets, signing secrets, store domains, and scopes in Martini secure, environment-specific configuration.
- Verify Shopify’s HMAC signature before processing an HTTPS webhook.
- Request only the scopes required for Products, Orders, Customers, inventory, fulfillment, or other selected objects.
- Protect commercially sensitive and personally identifiable customer and order data through field filtering and controlled API exposure.
- Keep Shopify store, market, location, and regional configuration explicit in multi-store deployments.
Operational considerations for Shopify Plus integrations
Rate limits and pagination
Shopify applies request-based REST limits and calculated query-cost limits to GraphQL. Workflows should inspect throttling information, request only required fields, control concurrency, and use bounded exponential backoff.
Webhooks and idempotency
Webhook topics are selected rather than universal. Acknowledge promptly, verify signatures, handle retries and out-of-order delivery, and persist event or resource keys before non-repeatable downstream actions.
Bulk and reconciliation workflows
Bulk operations are asynchronous. Store operation identifiers, track status, process result files incrementally, and record checkpoints to prevent duplicate imports. Scheduled reconciliation should recover missed events.
Versioning and schema changes
Pin Shopify API versions, plan upgrades before support boundaries, and test GraphQL schema, metafield definitions, and target mappings before production rollout.
Testing and monitoring
Test representative orders, catalog changes, inventory locations, customer permissions, staged uploads, retries, and duplicate events. Monitor workflow logs, API failures, throttling, checkpoints, and reconciliation results.
Why use Martini instead of scripts or point-to-point integrations?
Reusable orchestration
Martini separates Shopify intake, API retrieval, transformation, business rules, target writes, and error handling into maintainable workflows rather than embedding the integration in a single script.
Event and batch flexibility
The same integration estate can combine Shopify webhooks for near-real-time changes, scheduled reconciliation for recovery, paginated reads for incremental work, and bulk operations for large datasets.
Controlled data movement
Martini can apply field-level mappings, consent and scope rules, idempotency controls, and system-of-record decisions before data reaches ERP, CRM, fulfillment, tax, or commerce-channel applications.
Operational reliability
Centralized configuration, reusable workflow assets, bounded retries, checkpoints, logging, and monitoring provide a stronger operational model than disconnected point-to-point scripts.
API reuse
Martini can expose normalized APIs for downstream applications, allowing Shopify authentication and data-shaping logic to be managed in one integration layer.
Frequently asked questions
Shopify Plus can be integrated through Shopify’s GraphQL Admin API, legacy REST Admin API, selected HTTPS webhooks, asynchronous GraphQL bulk operations, and supported file or staged-upload operations. Enterprise workflows typically combine webhook-driven updates with scheduled reconciliation, pagination, and bulk processing.
Yes. Martini can consume Shopify GraphQL and REST APIs, receive Shopify HTTPS webhook events, run scheduled and bulk synchronization workflows, map Shopify objects to enterprise applications, and expose APIs for normalized Shopify data. A dedicated native Martini Shopify connector is not confirmed in the supplied documentation.
No. A dedicated Shopify Plus connector is not required. Martini can use Shopify’s confirmed native integration mechanisms, including GraphQL and REST APIs, HTTPS webhooks, bulk operations, file operations, and Shopify authentication and access-token patterns.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Shopify Plus. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Shopify, cloud infrastructure, or other third-party systems depending on subscriptions, API usage, and deployment model.
For new administrative integrations, Shopify’s GraphQL Admin API is generally the preferred option. REST Admin APIs remain relevant for existing applications and selected operations but are documented as legacy for new public app development. Storefront and Customer Account APIs apply to supported customer-facing use cases.
Yes. Martini can receive Shopify HTTPS webhook notifications, verify the HMAC signature, acknowledge promptly, and invoke an asynchronous workflow. Shopify webhook coverage is topic-specific, so API reads and scheduled reconciliation remain necessary for changes not covered by selected topics.
A robust design combines webhook-driven updates, cursor-based API reads, updated-at filters where supported, scheduled reconciliation, and bulk operations for large loads. Martini can persist Shopify event identifiers, resource IDs, operation IDs, and checkpoints so retries and out-of-order delivery do not create duplicate downstream orders or updates.
Yes. Martini can expose a controlled API that normalizes Shopify Products, Orders, Customers, inventory, or fulfillment data for downstream applications. The façade can centralize authentication, field filtering, transformation, business rules, and consistent error handling without exposing Shopify credentials directly.
Related Martini documentation
Shopify APIs
Workflows
Operations
Build a maintainable Shopify Plus integration with Martini
Use Martini to connect Shopify Plus APIs and webhooks with enterprise applications through secure workflows, reusable mappings, scheduled reconciliation, and reliable operational controls.