.png)
Shippo Integration Guide
Connect Shippo shipping operations with commerce, ERP, fulfillment, and customer service systems through REST APIs, selected webhook events, and Martini workflows.
Shippo integration options at a glance
Shippo’s primary integration method is its REST API, which supports addresses, parcels, shipments, rates, transactions, trackings, orders, batches, and related shipping resources. Shippo also provides webhook-style notifications for selected events, including tracking updates, although coverage must be confirmed for each event and resource. Batch functionality supports grouped shipment processing, while labels and documents may be returned as URLs or encoded formats rather than through a general file API. API access uses Bearer tokens. Martini can securely consume Shippo endpoints, receive and validate webhook requests, orchestrate batch and scheduled workflows, transform payloads, and synchronize shipping outcomes with downstream applications.
| Integration point | Supported by Shippo? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Create and retrieve Addresses, Parcels, Shipments, Rates, Transactions, Trackings, Orders, Batches, and related shipping resources. | Martini can consume Shippo REST endpoints from workflows, map request and response payloads, apply business rules, and route results to other systems. |
| Webhooks / outbound callbacks | Limited | Receive selected shipment tracking and configured account or object event notifications. Coverage is not universal across all resources or API operations. | Martini can expose an API endpoint, validate the request, parse the event, retrieve the current resource when necessary, and process the notification asynchronously. |
| Bulk / batch APIs | Yes | Group shipment operations for fulfillment runs and monitor batch processing results. | Martini can create or populate Shippo batches, orchestrate status polling, separate successful and failed operations, and persist results. |
| Authentication | Yes | Authenticate direct Shippo API requests with Bearer API tokens and maintain separate test and live credentials. | Martini can store tokens in secure environment configuration and inject them into REST requests without embedding credentials in workflow definitions. |
| Scheduled synchronization | Yes | Reconcile Transactions, Trackings, and related resources when webhook delivery is delayed or periodic verification is required. | Martini can run scheduled workflows with pagination, checkpoints, controlled throughput, and exception reporting. |
| File / attachment APIs | Not confirmed | Transaction responses may include label or document URLs or encoded formats, but no general Shippo file or attachment API was confirmed. | Martini can process confirmed response URLs or document values as part of a workflow, but should not assume Shippo provides general-purpose file storage. |
| GraphQL APIs | Not confirmed | No official Shippo GraphQL API was confirmed in the reviewed materials. | Martini integrations should use the confirmed Shippo REST API rather than assume GraphQL support. |
| SOAP APIs | Not confirmed | No official Shippo SOAP API was confirmed. | Martini integrations should use Shippo REST endpoints and selected webhook notifications instead. |
How Shippo exposes data and business events
Shippo REST APIs
Shippo’s REST API is the principal integration model for creating and retrieving Addresses, Parcels, Shipments, Rates, Transactions, Trackings, Orders, Batches, and related resources. Direct access uses Bearer API tokens.
Martini implementation pattern
Martini implementation pattern: a workflow retrieves source data or accepts an internal API request, calls the required Shippo endpoint, validates the response, maps Shippo objects into a canonical model, and writes the result to downstream systems. Secrets remain in secure environment configuration.
Implementation sequence
Shippo Webhook Notifications
Shippo supports webhook-style notifications for selected events, including tracking updates and other configured account or object events. Notifications do not represent every API operation or every resource change.
Martini implementation pattern
Martini implementation pattern: a Martini API receives the notification, validates it using Shippo’s documented webhook security method, records a normalized event envelope, and invokes a workflow to retrieve the current resource when the payload is incomplete. Deduplication and retry handling protect downstream updates.
Implementation sequence
Shippo Batch APIs
Shippo provides batch-oriented functionality for grouping shipment operations and coordinating fulfillment runs. Current limits, supported operations, and processing status behavior should be confirmed for the implementation.
Martini implementation pattern
Martini implementation pattern: a workflow selects ready-to-ship items, creates or populates a Shippo batch, monitors processing results, and separates successful labels from failed operations. It can then persist tracking references and coordinate Manifest processing where required.
Implementation sequence
Scheduled Shippo Reconciliation
Scheduled API retrieval provides a safety net for missed webhook notifications and supports periodic verification of Transactions, Trackings, and related shipping resources.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow retrieves paginated Shippo resources for a defined time range, resumes from a stored checkpoint, compares results with the order or fulfillment system, and produces an exception result for mismatches.
Implementation sequence
Common Shippo integration patterns
Pattern 1: Convert commerce orders into Shippo labels
When to use this pattern
Use this pattern when an order in a commerce platform must become a validated Shippo shipment, rate selection, and purchased label. It separates address and parcel validation from label purchasing so invalid input does not create partial fulfillment state.
Integration direction
Example Mapping
| Shippo Field | Canonical Field | Target Field |
|---|---|---|
| shipping_address | destinationAddress | Shippo Addresses |
| package.weight | parcelWeight | Shippo Parcels |
| shipping_service | requestedServiceLevel | Shippo Rates |
| tracking_number | trackingNumber | Shopify fulfillment |
Martini implementation pattern
Martini receives the order, validates address and package fields, creates Shippo Addresses, Parcels, and Shipments, retrieves Rates, and applies cost, destination, service-level, or delivery rules. It creates a Transaction only after a valid rate is selected, then writes the confirmed label URL and tracking number back to the commerce system. Transient failures are retried and label-purchase timeouts are checked before any repeat transaction.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
- secrets management
Pattern 2: Propagate Shippo tracking events
When to use this pattern
Use this pattern when selected Shippo tracking notifications should update order, fulfillment, ERP, CRM, or customer service systems quickly. A scheduled reconciliation workflow can supplement event delivery.
Integration direction
Example Mapping
| Shippo Field | Canonical Field | Target Field |
|---|---|---|
| tracking_status | fulfillmentStatus | Salesforce fulfillment status |
| tracking_number | shipmentReference | Zendesk case context |
| tracking_status_details | deliveryExceptionReason | Support notification |
Martini implementation pattern
Martini receives and validates a selected Shippo webhook, checks the event identifier for duplicates, retrieves Trackings data when needed, and maps carrier-specific values into controlled downstream statuses. Delivery exceptions are routed to support or operations workflows, while malformed or temporarily unavailable events are logged and retried.
Martini capabilities used
- API exposure
- webhook handling
- workflow orchestration
- data mapping
- conditional routing
- deduplication
Pattern 3: Process batch fulfillment and manifests
When to use this pattern
Use this pattern for fulfillment runs where multiple ready-to-ship orders must be grouped, processed, and reconciled separately by success and failure outcome.
Integration direction
Example Mapping
| Shippo Field | Canonical Field | Target Field |
|---|---|---|
| fulfillment_lines | batchShipmentItems | Shippo batch |
| label_url | shippingDocumentReference | NetSuite fulfillment |
| tracking_number | carrierTrackingReference | NetSuite fulfillment |
Martini implementation pattern
Martini selects eligible fulfillment records, validates each package, creates or populates a Shippo batch, monitors processing status, and persists successful Transactions and tracking references. Failed operations remain separately actionable, and Manifest retrieval or creation is performed only where the carrier handoff process requires it.
Martini capabilities used
- scheduled workflows
- batch orchestration
- data transformation
- business rules
- error handling
- monitoring
Pattern 4: Reconcile Shippo shipping status
When to use this pattern
Use this pattern when an organization needs a recurring control process for missed webhooks, stale tracking statuses, failed label purchases, or mismatched shipment identifiers.
Integration direction
Example Mapping
| Shippo Field | Canonical Field | Target Field |
|---|---|---|
| transaction_id | shippingTransactionId | NetSuite fulfillment |
| tracking_status | normalizedDeliveryStatus | NetSuite fulfillment status |
| object_updated | lastVerifiedAt | NetSuite synchronization metadata |
Martini implementation pattern
A scheduled Martini workflow retrieves paginated Transactions and Trackings for a bounded time range, resumes from a checkpoint, compares identifiers and statuses with the target system, and applies only required updates. It creates an exception report for missing labels, stale events, and mismatches while preserving original Shippo status values for auditability.
Martini capabilities used
- scheduler triggers
- API consumption
- pagination handling
- mapping and transformation
- idempotent updates
- monitoring
Applications commonly integrated with Shippo
Shippo can be integrated with commerce, ERP, marketplace, and customer service applications to automate shipment creation, label purchasing, tracking updates, and delivery exception handling. The exact object mappings depend on each application’s implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Create shipping labels, write tracking numbers back to fulfillments, and synchronize delivery status. | Shopify → Martini → Shippo → Martini | Martini receives Shopify order or fulfillment data, maps addresses and package details to Shippo Addresses, Parcels, and Shipments, retrieves Rates, purchases a Transaction, and writes the label URL and tracking number back to Shopify with retry and duplicate safeguards. |
| WooCommerce | Generate labels and tracking information for WooCommerce orders. | WooCommerce → Martini → Shippo → Martini | A Martini workflow retrieves ready-to-ship WooCommerce orders, validates shipping data, calls Shippo REST endpoints, applies service-selection rules, and updates WooCommerce after a confirmed transaction response. |
| BigCommerce | Automate shipment creation, rate selection, label purchase, and fulfillment updates. | BigCommerce → Martini → Shippo → Martini | Martini transforms BigCommerce order and package data into Shippo request models, compares returned rates using business rules, creates a Transaction, and routes failures to an operational exception workflow. |
| NetSuite | Synchronize sales orders and fulfillment records with Shippo shipping transactions and tracking results. | NetSuite → Martini → Shippo → Martini | Martini reads fulfillment-ready NetSuite data, creates or retrieves Shippo shipping resources, persists Shippo identifiers, and reconciles tracking and label status back to NetSuite on a schedule or selected webhook events. |
| Salesforce | Update order, fulfillment, or case-related information with tracking statuses and delivery exceptions. | Shippo → Martini → Salesforce | Martini receives selected Shippo tracking notifications, retrieves current Trackings data when needed, translates carrier statuses into Salesforce values, and updates the relevant records idempotently. |
| Amazon | Coordinate marketplace order fulfillment and tracking information with Shippo-managed shipments. | Amazon → Martini → Shippo → Martini | Martini receives eligible Amazon order data, maps it to Shippo shipment structures, coordinates label purchasing, and returns tracking references while isolating marketplace-specific errors for retry or review. |
| Zendesk | Make shipment and delivery status available to customer service workflows and support cases. | Shippo → Martini → Zendesk | Martini consumes selected Shippo tracking events or runs reconciliation workflows, normalizes shipment status and exceptions, and updates Zendesk case or customer-facing support context without exposing Shippo credentials. |
How to build a Shippo integration in Martini
Objective
Configure Shippo test or live API credentials and downstream endpoint settings without embedding secrets in workflow definitions.
Instructions in Martini
- Store Shippo Bearer tokens in Martini secure environment configuration
- Separate test and live credentials and callback URLs
- Configure downstream authentication and endpoint values by environment
Objective
Select the event, API, batch, or schedule that starts each integration flow.
Instructions in Martini
- Use a Martini API for selected Shippo webhook notifications
- Use an application event or API request for shipping creation
- Use a scheduler for reconciliation and periodic verification
- Use workflow orchestration for batch fulfillment
Objective
Obtain the relevant Shippo resource while respecting selected event coverage, pagination, and resource completeness.
Instructions in Martini
- Validate webhook authenticity before processing
- Retrieve Trackings or other current resources when the event payload is incomplete
- Follow documented pagination fields and continuation links
- Persist checkpoints for recurring synchronization
Objective
Coordinate validation, Shippo calls, business rules, downstream updates, and exception paths in a maintainable Martini workflow.
Instructions in Martini
- Separate validation from label purchasing
- Route rate, address, carrier, and payment failures distinctly
- Use controlled retries with backoff for transient failures
- Check durable identifiers before repeating operations
Objective
Translate Shippo objects and status values into canonical and target-system models.
Instructions in Martini
- Map Addresses, Parcels, Shipments, Rates, Transactions, and Trackings explicitly
- Normalize units, country codes, postal formats, and carrier statuses
- Preserve original Shippo identifiers and status values
- Transform label and tracking references for each target application
Objective
Select shipping services and determine downstream actions based on operational requirements.
Instructions in Martini
- Compare Rates by service level, destination, cost, and delivery estimate
- Apply rules for address validation and package eligibility
- Route delivery exceptions to operations or customer service
- Prevent duplicate label purchases after timeouts
Common Shippo data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Addresses | Represent origin, destination, and return addresses for shipping operations. | Shopify, WooCommerce, BigCommerce, NetSuite, Amazon | Martini validates required fields and country or postal formats, maps source addresses to Shippo request fields, and preserves identifiers for later reconciliation. |
| Parcels | Describe package dimensions, weight, and packaging information. | Commerce platforms, NetSuite, warehouse applications | Martini converts units and package structures, validates dimensions and weight, and combines parcels with Addresses to construct Shipments. |
| Shipments | Represent a shipping request used to obtain available Rates. | Shopify, BigCommerce, WooCommerce, NetSuite | Martini constructs Shipments from validated addresses and parcels, submits them through REST workflows, and routes address or service validation failures. |
| Rates | Provide carrier service options and prices for a Shipment. | Commerce platforms, order management, customer service | Martini filters and ranks Rates using destination, service level, cost, and delivery rules before label purchase. |
| Transactions | Represent purchased shipping labels and related label or tracking information. | Commerce platforms, ERP, fulfillment, customer service | Martini stores the confirmed transaction identifier, label URL, and tracking number, using idempotency controls to reduce duplicate purchases. |
| Trackings | Provide shipment tracking information and status updates. | Shopify, Salesforce, NetSuite, Zendesk, customer notification services | Martini consumes selected webhook events or scheduled API results, normalizes carrier statuses, and updates downstream systems idempotently. |
Authentication and security considerations
Token-based access
Shippo direct API access uses Bearer API tokens. Store test and live tokens in Martini secure environment configuration rather than workflow definitions, source code, or logs.
Webhook validation
Shippo webhook requests should be validated using the current Shippo webhook security guidance. A request should not be trusted solely because it reached a configured Martini endpoint.
Environment separation
- Keep Shippo test and live credentials separate.
- Use environment-specific callback URLs and downstream credentials.
- Limit access to the Shippo account and environment required by each workflow.
- Sanitize logs to avoid exposing tokens and unnecessary address data.
Operational considerations for Shippo integrations
Throughput and pagination
Confirm current Shippo rate limits and use bounded, paginated retrievals. Apply backoff for throttling and transient HTTP failures, and use batch or scheduled processing for larger fulfillment runs.
Idempotency and retries
Webhook notifications may be retried or delivered more than once. Persist stable event, transaction, or tracking identifiers and check them before downstream updates. Protect label purchasing from duplicate Transactions after timeouts.
Data quality and schema changes
Validate addresses, dimensions, weight, units, country codes, and postal formats before creating Shipments. Translate tracking statuses through a controlled mapping layer, preserve original values, and monitor for new fields or event values.
Testing and observability
Separate test and production resources, callback URLs, and credentials. Log sanitized identifiers, HTTP statuses, workflow outcomes, and error details, and use scheduled reconciliation to detect missed events or stale statuses.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini provides a workflow layer for coordinating Shippo API calls, selected webhook events, validation, rate selection, label purchasing, downstream updates, and reconciliation without duplicating the same logic across point-to-point scripts.
Reusable data transformation
Mappings and business rules can translate Shippo Addresses, Parcels, Shipments, Rates, Transactions, and Trackings into canonical models for multiple applications while preserving vendor identifiers and original statuses.
Operational control
Martini supports secure configuration, scheduled execution, conditional routing, retry handling, logging, and reusable APIs. This makes exceptions such as invalid addresses, unavailable rates, duplicate events, and failed label purchases easier to monitor and troubleshoot.
Frequently asked questions
Shippo is integrated primarily through its REST API, which supports shipping resources such as Addresses, Parcels, Shipments, Rates, Transactions, Trackings, Orders, and Batches. Shippo also provides webhook-style notifications for selected events. Enterprise workflows can combine API calls, selected event notifications, batch processing, and scheduled reconciliation.
Yes. Martini can consume the Shippo REST API, expose an API endpoint for selected Shippo webhook notifications, securely use Shippo API tokens, transform shipping data, and coordinate updates to commerce, ERP, fulfillment, and customer service systems.
No. A dedicated Shippo connector is not required. Martini can integrate with Shippo using its confirmed REST API, selected webhook notifications, batch functionality, and Bearer token authentication.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Shippo. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Shippo, cloud infrastructure, carriers, or other third-party systems based on subscription, usage, and deployment model.
The Shippo REST API is the recommended primary method for creating and retrieving shipping resources. Selected webhook-style notifications are useful for tracking updates and other configured events, while batch APIs support grouped fulfillment operations. No official Shippo GraphQL or SOAP API was confirmed.
Yes, Shippo supports webhook-style notifications for selected events, including tracking updates. Coverage must be checked for the specific event and resource, and notifications should be validated, deduplicated, and supplemented with scheduled reconciliation where necessary.
Martini can use event-driven workflows for selected notifications and scheduled workflows for reconciliation. It can retrieve paginated resources, store checkpoints, compare Shippo identifiers and statuses with downstream systems, and update only records that require synchronization.
Yes. Martini can expose a controlled API that accepts an internal shipping request, validates and transforms it, calls Shippo REST endpoints, applies business rules, and returns a normalized response. This can isolate downstream applications from Shippo-specific payloads and credentials.
Related Martini documentation
Connect Shippo with your enterprise systems
Use Martini to build secure Shippo integrations that coordinate shipping workflows, tracking events, batch fulfillment, and reconciliation across your commerce and operational applications.