.png)
eBay Integration Guide
Integrate eBay with enterprise systems through REST APIs, selected notifications, SOAP/XML services, and feed-based workflows.
eBay integration options at a glance
eBay’s primary integration model is its REST API platform, covering Buy, Commerce, and Sell capabilities for products, inventory, offers, listings, orders, fulfillment, notifications, and reporting. Existing integrations can also use the legacy Trading API over SOAP/XML where REST coverage is insufficient. Selected event topics are available through eBay’s Notification API, while the Sell Feed API supports asynchronous, file-based processing for supported bulk operations. Martini can obtain and refresh OAuth 2.0 tokens, call these APIs, receive supported callbacks, process JSON or XML, orchestrate feed tasks, and map eBay data into ERP, commerce, warehouse, CRM, or analytics workflows.
| Integration point | Supported by eBay? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | eBay Buy, Commerce, and Sell REST APIs support product discovery, inventory, offers, listings, orders, fulfillment, account, marketing, analytics, and related operations. JSON, pagination, filters, marketplace context, and OAuth 2.0 are commonly involved. | Martini can consume eBay REST APIs from workflows and APIs, map JSON payloads, manage token configuration, apply business rules, and expose reusable internal API operations. |
| SOAP/XML APIs | Legacy | The eBay Trading API supports traditional listing, order, inventory, and account operations for existing integrations or capabilities not available through applicable REST APIs. | Martini can consume SOAP services and transform XML payloads, while workflows can isolate legacy operations behind reusable services or APIs. |
| Webhooks / outbound callbacks | Limited | eBay’s Notification API provides webhook-style notifications for selected order, fulfillment, item, listing, account, and other topics. Coverage is not universal across all objects or state changes. | Martini can expose an API endpoint or webhook-triggered workflow, validate and process callbacks, deduplicate events, and use scheduled reconciliation for missed or unsupported events. |
| Bulk / async / batch APIs | Yes | The Sell Feed API supports feed tasks, file upload or download, asynchronous processing, and selected large-volume inventory, listing, or order-related operations. | Martini can create feed tasks, poll task status, upload or download files, parse results, record item-level errors, and route safe retries. |
| File / attachment APIs | Limited | eBay supports feed files for selected batch operations and a Media API for listing-related images and videos. It does not provide one universal attachment model for every object. | Martini can process supported files and media responses, transform content and metadata, and coordinate media or feed operations within workflows. |
| Analytics and reporting APIs | Yes | The Sell Analytics API provides seller performance and sales-related reports. It provides reporting access rather than direct database connectivity. | Martini can schedule report retrieval, normalize report data, and write results to databases, warehouses, or reporting applications. |
| Authentication | Yes | Modern eBay APIs use OAuth 2.0 application access tokens or user access tokens. Client ID, client secret, Dev ID, scopes, RuName configuration, and refresh tokens may be required. | Martini can keep credentials and refresh tokens in secure configuration, call token endpoints, separate application and user authorization, and use only required scopes. |
| Database access | No | eBay does not provide direct database access. Operational data should be retrieved through APIs, feeds, notifications, and reports. | Martini can persist synchronization state in an approved internal database or service while using eBay APIs as the system interface. |
How eBay exposes data and business events
eBay REST APIs
eBay’s current API platform includes Buy, Commerce, and Sell REST APIs for marketplace products, inventory, offers, listings, orders, fulfillment, account operations, marketing, and analytics. These APIs generally use JSON, OAuth 2.0, pagination, filters, and marketplace-specific context.
Martini implementation pattern
Martini workflows obtain or refresh the appropriate OAuth token, call the required eBay REST endpoint, validate the response, transform the payload into a canonical model, and write it to the target system. Reusable Martini APIs can expose controlled internal operations while synchronization state records IDs, cursors, timestamps, and outcomes.
Implementation sequence
eBay Notifications
eBay’s Notification API supports webhook-style callbacks for selected topics, including some order, fulfillment, item, listing, and account events. Notification coverage varies by topic and is not a universal event stream.
Martini implementation pattern
Martini exposes an API endpoint or webhook-triggered workflow to receive supported eBay callbacks. The workflow validates the notification, records an event fingerprint, retrieves current eBay state when needed, and uses periodic polling to reconcile missed or unsupported events.
Implementation sequence
eBay Trading API
The Trading API is a legacy SOAP/XML interface that remains relevant for existing integrations and operations not covered by a suitable REST API. New development should generally prefer applicable REST APIs.
Martini implementation pattern
Martini consumes the SOAP service, configures the required credentials and operation details, parses XML responses, and isolates legacy operations behind reusable workflows or an internal API. XML faults and eBay business errors are handled separately from transport failures.
Implementation sequence
eBay Sell Feed API
The Sell Feed API supports asynchronous feed tasks and file-based processing for selected high-volume inventory, listing, and order-related operations. Feed task types and formats are operation-specific.
Martini implementation pattern
Martini creates a feed task, uploads or downloads the supported file, polls asynchronous status, and processes the result only after completion. Item-level successes and errors are persisted so failed rows can be reviewed or retried safely.
Implementation sequence
eBay Media API
eBay’s Media API supports uploading and managing images and videos used by listings and other commerce experiences. This is a focused media capability rather than a universal attachment API.
Martini implementation pattern
Martini retrieves approved media from a source system, transforms or validates metadata as required, calls the eBay Media API, and passes returned media references into listing or catalog workflows. Media failures are tracked independently from inventory or offer updates.
Implementation sequence
Common eBay integration patterns
Pattern 1: Synchronize inventory and offers
When to use this pattern
Use this pattern when an ERP, PIM, or commerce platform is the source of product availability and pricing while eBay is the marketplace publication target. It supports scheduled incremental synchronization with stable SKU and Offer identifiers.
Integration direction
Example Mapping
| eBay Field | Canonical Field | Target Field |
|---|---|---|
| sku | productSku | Inventory Item SKU |
| availableQuantity | availableQuantity | availability.shipToLocationAvailability.quantity |
| price | salePrice | Offer pricingSummary.price |
| marketplaceId | marketplace | Offer marketplaceId |
Martini implementation pattern
A scheduled Martini workflow retrieves changed products, validates SKU, marketplace, condition, and policy dependencies, then updates Inventory Items and Offers in the required order. It stores eBay IDs and synchronization checkpoints, uses idempotent updates, and retries throttling or transient API failures with bounded backoff.
Martini capabilities used
- workflows
- scheduler triggers
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Synchronize eBay orders and fulfillment
When to use this pattern
Use this pattern to move eBay Orders into an ERP, order-management, warehouse, or shipping platform and send shipment and tracking information back to eBay. User authorization and suitable fulfillment scopes are required.
Integration direction
Example Mapping
| eBay Field | Canonical Field | Target Field |
|---|---|---|
| orderId | externalOrderId | externalOrderId |
| lineItems[].sku | productSku | orderLines[].sku |
| lineItems[].quantity | orderedQuantity | orderLines[].quantity |
| trackingNumber | shipmentTrackingNumber | shipments[].trackingNumber |
Martini implementation pattern
Martini polls the Fulfillment API and optionally consumes supported notification topics, maps Orders and line items into the downstream model, and records eBay Order IDs before creating downstream orders. A second workflow sends confirmed shipment and tracking data to eBay, with duplicate checks and reconciliation for missed events.
Martini capabilities used
- workflows
- API consumption
- data mapping
- scheduled synchronization
- business rules
- retry handling
Pattern 3: Publish catalog listings with media
When to use this pattern
Use this pattern when a product catalog or PIM must publish structured products, images, pricing, and fulfillment information to eBay. Listing dependencies should be sequenced so media, Inventory Items, Offers, policies, and publication state are traceable.
Integration direction
Example Mapping
| eBay Field | Canonical Field | Target Field |
|---|---|---|
| productCode | productSku | Inventory Item SKU |
| title | productTitle | product.title |
| imageUrls[] | mediaReferences | imageUrls |
| categoryCode | marketplaceCategory | categoryId |
Martini implementation pattern
Martini orchestrates media upload, product attribute mapping, taxonomy or category handling, Inventory Item updates, Offer creation, and listing publication. Validation failures are returned to the catalog process, while transient failures are retried and partial completion is retained for reconciliation.
Martini capabilities used
- workflow orchestration
- API consumption
- data transformation
- validation
- business rules
- error handling
Pattern 4: Reconcile high-volume feed operations
When to use this pattern
Use this pattern for supported bulk inventory, listing, or order-related operations where individual API calls are inefficient or the Sell Feed API is the documented interface.
Integration direction
Example Mapping
| eBay Field | Canonical Field | Target Field |
|---|---|---|
| internalSku | productSku | feed SKU |
| quantity | availableQuantity | feed quantity |
| offerPrice | salePrice | feed price |
| resultErrorCode | processingErrorCode | reconciliation errorCode |
Martini implementation pattern
A Martini workflow creates and submits the appropriate feed task, tracks task IDs, polls status, downloads result files, and parses item-level outcomes. Successful rows update synchronization state; retryable errors are isolated from permanent validation errors and retained for controlled reprocessing.
Martini capabilities used
- scheduled workflows
- file processing
- API consumption
- mapping and transformation
- state persistence
- error handling
Applications commonly integrated with eBay
eBay marketplace data can be coordinated with commerce, ERP, shipping, CRM, and customer-service applications. The exact object coverage depends on each application’s APIs, seller permissions, marketplace, and implementation scope.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Synchronize products, inventory, prices, orders, and fulfillment status between a Shopify storefront and eBay marketplace operations. | Shopify → Martini → eBay | Use scheduled workflows and supported notifications to retrieve Shopify changes, map products and SKUs to eBay Inventory Items and Offers, and send eBay Orders and fulfillment updates back to Shopify. Persist marketplace and correlation identifiers to make updates idempotent. |
| Salesforce | Align eBay orders, buyer context, and seller service activity with CRM and customer-service processes. | eBay → Martini → Salesforce | Retrieve eBay Orders or supported notification events, normalize buyer and order information, apply privacy and business rules, and write approved data to Salesforce through its APIs. Route validation and authorization failures separately from transient retries. |
| NetSuite | Synchronize marketplace orders, products, inventory, pricing, and fulfillment with ERP processes. | eBay → Martini → NetSuite | Use workflows to poll the eBay Fulfillment and Sell APIs, map Orders and line items into NetSuite transactions, and publish inventory, offer, and shipment changes from NetSuite back to eBay. Store eBay IDs, SKUs, and processing state for reconciliation. |
| Amazon | Coordinate multi-marketplace catalog, inventory, and order operations through a shared commerce or order-management model. | eBay → Martini → Amazon | Use Martini as an orchestration layer that normalizes inventory, catalog, and order data from both marketplaces. Apply marketplace-specific mappings and business rules before sending each platform’s supported API requests. |
| ShipStation | Send eBay orders for shipping execution and return shipment and tracking information to eBay. | eBay → Martini → ShipStation | Retrieve eBay Orders, map order lines and delivery information to ShipStation, then consume shipment results and call eBay fulfillment operations with tracking data. Use order and fulfillment identifiers to prevent duplicate shipments. |
| SAP S/4HANA | Integrate marketplace sales, inventory, fulfillment, and financial processing with enterprise ERP workflows. | eBay → Martini → SAP S/4HANA | Orchestrate eBay API calls and SAP API exchanges through reusable workflows. Transform marketplace objects into SAP business structures, validate required fields, and maintain a reconciliation store for orders, inventory, and fulfillment states. |
| Microsoft Dynamics 365 | Synchronize eBay sales with ERP, customer service, inventory, and fulfillment processes. | eBay → Martini → Microsoft Dynamics 365 | Poll or receive supported eBay notifications, map Orders and fulfillment information into Dynamics 365, and publish approved inventory and shipment updates to eBay. Use retry policies for throttling and durable state for incremental synchronization. |
| Zendesk | Provide support teams with eBay order, listing, and buyer context for customer-service workflows. | eBay → Martini → Zendesk | Retrieve relevant eBay order or buyer-service context, apply data minimization rules, and create or enrich Zendesk records through its API. Keep operational updates linked to eBay identifiers without treating notifications as a complete synchronization source. |
How to build a eBay integration in Martini
Objective
Establish eBay application or seller authorization with the least-privilege scopes required by each workflow.
Instructions in Martini
- Store Client ID, client secret, Dev ID, RuName configuration, and refresh tokens as Martini secrets
- Use OAuth 2.0 application tokens for application-level operations and user tokens for seller-authorized data
- Separate sandbox and production credentials and configuration
Objective
Select an event, schedule, or API entry point that matches the synchronization requirement and eBay’s event coverage.
Instructions in Martini
- Use a webhook-triggered workflow for supported eBay notification topics
- Use a scheduler for polling, reconciliation, reports, and feed tasks
- Expose a Martini API when another application should initiate an eBay operation
Objective
Call the appropriate eBay API or process a supported feed and retain the state needed for incremental processing.
Instructions in Martini
- Call the relevant REST endpoint with marketplace and language context
- Use the Trading API only where a legacy SOAP/XML operation is required
- Handle pagination, continuation information, feed task status, and result files
Objective
Coordinate dependent eBay operations and downstream systems as a durable business process.
Instructions in Martini
- Sequence Inventory Items, Offers, Listings, media, policies, Orders, and Fulfillment operations according to dependencies
- Persist eBay IDs, SKUs, task IDs, cursors, and correlation identifiers
- Use bounded concurrency and queues or staged workflows for high-volume processing
Objective
Transform eBay JSON, XML, notification, or feed data into canonical and target-system models.
Instructions in Martini
- Map actual eBay objects such as Orders, Inventory Items, Offers, Listings, and Fulfillment
- Validate required fields, marketplace context, scopes, policy dependencies, and business rules
- Preserve unknown response fields where useful for forward-compatible processing
Objective
Create or update downstream ERP, commerce, warehouse, shipping, CRM, database, or reporting data and send approved updates back to eBay.
Instructions in Martini
- Use stable identifiers to make writes idempotent
- Record target responses and eBay correlation identifiers
- Separate business validation failures from transient transport or throttling failures
Common eBay data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Item | Represents a product or listing exposed through eBay buying and commerce APIs. | Product catalogs, search applications, commerce platforms, and analytics stores | Martini retrieves Item data through applicable APIs, maps marketplace attributes into canonical product models, and applies marketplace-specific rules. |
| Inventory Item | Contains seller-managed SKU, product information, condition, and availability data. | ERP, PIM, warehouse, commerce platforms, and inventory databases | Martini maps internal SKU and inventory changes to eBay Inventory Item operations and stores SKU and marketplace identifiers for idempotent updates. |
| Offer | Defines a seller’s price, marketplace, listing format, and quantity for an Inventory Item. | ERP, pricing systems, PIM, and marketplace management platforms | Workflows validate dependencies such as Inventory Item, marketplace, and business policies before creating or revising Offers. |
| Listing | Represents the published marketplace listing created from an Offer. | Commerce platforms, catalog systems, reporting stores, and operational dashboards | Martini sequences inventory, offer, media, and publication operations, then persists Listing IDs and status for reconciliation. |
| Order | Represents a buyer purchase containing one or more order line items. | ERP, order-management systems, warehouses, shipping platforms, and CRM applications | Martini retrieves Orders through the Fulfillment API or supported notifications, maps line items and delivery data, and applies duplicate-prevention rules. |
| Fulfillment | Contains shipment and fulfillment information associated with an eBay Order. | Shipping platforms, warehouse systems, ERP, and customer-service applications | Martini maps shipment and tracking results from downstream systems to eBay fulfillment operations and records fulfillment identifiers and outcomes. |
Authentication and security considerations
OAuth 2.0 and scoped access
Modern eBay REST APIs use OAuth 2.0. Application access tokens support application-level operations, while user access tokens authorize seller or buyer data according to the granted scopes and marketplace permissions.
Secure credential management
Client secrets, Dev IDs, refresh tokens, and other credentials should be stored in Martini secure configuration rather than workflow definitions. Application credentials and seller-authorized credentials should remain separate.
Least privilege and environment separation
- Request only the scopes required for each workflow.
- Separate sandbox and production credentials, endpoints, data, and secrets.
- Protect exposed Martini APIs with appropriate authentication and authorization controls.
- Do not log access tokens, refresh tokens, or sensitive buyer information.
Operational considerations for eBay integrations
Rate limits and pagination
eBay APIs may throttle requests and list operations commonly require pagination or continuation handling. Use bounded concurrency, backoff, queues, and persisted checkpoints rather than assuming one response contains all data.
Dependencies and idempotency
Listing operations can depend on Inventory Items, Offers, marketplaces, categories, policies, and media. Use stable eBay identifiers and correlation state to prevent duplicate Offers, Listings, Orders, or fulfillment updates.
Notifications and reconciliation
Notification coverage is limited to selected topics. Account for duplicate or out-of-order callbacks and retain a scheduled reconciliation process based on current API state.
Feeds and schema changes
Track feed task IDs, wait for completion, parse item-level results, and retain source and result files when auditability is required. Tolerate unknown fields, track API versions, and test marketplace-specific behavior in sandbox and production.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrate more than API calls
Martini coordinates eBay authentication, dependent marketplace operations, downstream writes, validation, retries, and reconciliation in maintainable workflows rather than scattering logic across scripts.
Centralize mappings and business rules
Reusable mappings can transform eBay Inventory Items, Offers, Listings, Orders, and Fulfillment objects into ERP, commerce, warehouse, shipping, CRM, or reporting models while keeping marketplace-specific rules explicit.
Improve operational control
- Use scheduled, event-driven, API-led, and asynchronous feed workflows.
- Persist checkpoints, identifiers, task states, and error outcomes.
- Separate transient throttling failures from permanent validation errors.
- Expose controlled internal APIs instead of requiring every application to understand eBay authentication and object dependencies.
Frequently asked questions
eBay can be integrated through its REST APIs for Buy, Commerce, and Sell operations, selected Notification API callbacks, the legacy Trading API over SOAP/XML, Sell Feed API tasks, media endpoints, and analytics APIs. Enterprise workflows typically use OAuth 2.0, map objects such as Inventory Items, Offers, Listings, Orders, and Fulfillment, and maintain synchronization state for retries and reconciliation.
Yes. Martini can integrate with eBay by consuming eBay REST APIs, using the Trading API where legacy SOAP/XML coverage is required, receiving supported notification callbacks, and processing supported feed and media operations. It can orchestrate workflows, transform JSON or XML, apply business rules, and expose internal APIs for other systems.
No. A dedicated eBay connector is not required. Martini can use eBay’s confirmed native integration mechanisms, including REST APIs, OAuth 2.0, selected notifications, SOAP/XML services, feed files, media APIs, and reporting APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate eBay with Martini. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from eBay, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
New integrations should generally use the applicable eBay REST API for Buy, Commerce, or Sell capabilities. The Trading API is a legacy SOAP/XML option for existing integrations or operations not covered by the relevant REST API. Martini can consume either interface and transform the resulting JSON or XML.
Martini can expose an API endpoint or webhook-triggered workflow to receive eBay Notification API callbacks for selected topics. Coverage is not universal, and notifications may be duplicated, delayed, or missed, so important processes should also use scheduled API polling or reconciliation.
Martini can combine scheduled polling, supported notifications, and feed processing. Workflows should persist identifiers such as SKU, Offer ID, Listing ID, Order ID, Fulfillment ID, task ID, and event fingerprints. Idempotent writes, pagination handling, checkpoints, and periodic reconciliation help prevent duplicates and recover from incomplete delivery.
Yes. Martini can expose controlled REST APIs that hide eBay-specific authentication, marketplace headers, object dependencies, mappings, and error handling from internal applications. The façade can invoke reusable workflows for operations such as inventory updates, order retrieval, listing publication, or fulfillment updates.
Related Martini documentation
APIs
Integrate eBay with Martini
Build maintainable eBay integrations with Martini workflows, APIs, secure OAuth configuration, data mapping, notifications, and feed processing.