Ellipse Gradient for Header

Faire Integration Guide

Connect Faire’s approved partner REST APIs and selected webhook events with ERP, commerce, fulfillment, and business systems through Martini workflows.

Faire integration options at a glance

Faire’s primary integration model is an authenticated partner REST API for approved applications and integrations. Depending on account role and permissions, API access can support Products, Product variants, inventory, Orders, Shipments, Brands, and Retailers. Faire also supports webhook-style notifications for selected partner events, although event coverage and delivery behavior must be confirmed for each integration. Martini can consume Faire REST endpoints, expose an HTTP endpoint for supported notifications, schedule incremental synchronization, and map Faire data into ERP, commerce, fulfillment, accounting, or internal systems. Credentials are stored as environment-managed secrets, while pagination, rate limits, retries, idempotency, and reconciliation are handled within workflows.

Integration pointSupported by Faire?Common use casesHow Martini supports it
REST APIsYesFaire’s primary integration model supports approved partner access to Products, Product variants, inventory, Orders, Shipments, and related marketplace data, subject to program permissions.Martini can consume Faire REST endpoints from workflows, paginate collections, transform responses, apply business rules, and write results to downstream APIs or databases.
Webhooks / outbound callbacksLimitedFaire supports webhook-style notifications for selected events in approved partner integrations. Coverage should not be assumed for every object or state change.Martini can expose an HTTP endpoint, validate and record notifications, deduplicate events, and route them to downstream workflows.
AuthenticationLimitedAuthenticated partner access is required. API tokens, API keys, or OAuth-based authorization may apply depending on the Faire application or partner program.Martini stores credentials as environment-managed secrets and references them from API workflows; exact headers, scopes, and token lifecycle must be configured from Faire’s current documentation.
PaginationYesProduct and order collections should be processed using Faire’s documented pagination mechanism rather than assuming a fixed page size.Martini workflows can maintain cursor or page state, continue collection processing, and persist checkpoints for recovery.
Incremental synchronizationLimitedDocumented timestamps, cursors, or equivalent change filters should be used where available to avoid repeatedly downloading complete catalogs or order collections.Martini can persist synchronization state, retrieve changed data, and run scheduled reconciliation workflows.
Bulk / async / batch APIsNot confirmedA general-purpose bulk or asynchronous export API was not verified. Large transfers should use documented pagination and incremental queries unless Faire confirms another mechanism.Martini can orchestrate paginated batches and rate-limited workflows without assuming an unverified bulk endpoint.
File / attachment APIsNot confirmedProduct media may be represented by URLs, but a general-purpose Faire file or attachment API was not confirmed.Martini can process data exposed by documented API fields but should not assume generic upload or attachment operations.
Database / analytics accessNoNo direct Faire database, JDBC, or general analytics-access mechanism was identified.Martini should integrate through Faire’s API and supported event mechanisms rather than direct database access.

How Faire exposes data and business events

Faire REST APIs

Faire’s documented integration model is an authenticated partner REST API. Approved integrations may retrieve or manage Products, Product variants, inventory, Orders, Shipments, Brands, Retailers, and related marketplace data according to account role, API program, and permissions. Pagination, rate limits, API versions, and write access must be confirmed for the specific partner application.

Martini implementation pattern

Martini implements a workflow that authenticates to Faire using environment-managed credentials, calls the relevant REST endpoint, follows documented pagination, and stores synchronization state. The workflow maps Faire objects into a canonical model, applies validation and business rules, writes to target APIs or databases, and records errors for retry or reconciliation.

Implementation sequence

Authenticate the workflow with approved Faire credentials
Retrieve the required Faire collection or resource
Follow pagination until the collection is complete
Map Faire fields to the canonical integration model
Apply validation, identifier, and business rules
Write the transformed data to the target system idempotently ל

Faire webhook notifications

Faire supports webhook-style notifications for selected events in approved partner integrations. Notifications should be treated as event-specific rather than as complete coverage of every object or state change; event types, signatures, retries, and delivery guarantees require confirmation from current Faire documentation.

Martini implementation pattern

Martini exposes an HTTP API endpoint for supported Faire notifications. The receiving workflow validates the documented authentication or signature, records the event before acknowledging it, protects against duplicate delivery, and routes the event to ERP, order-management, fulfillment, or notification workflows. Scheduled reconciliation supplements event processing when completeness is business-critical.

Implementation sequence

Receive the Faire notification at a Martini API endpoint
Validate the documented authentication or signature
Record the event identifier and payload safely
Reject or quarantine duplicate or invalid notifications
Retrieve the current Faire resource when the event requires full state
Map the event to the target system model and apply business rules

Common Faire integration patterns

Pattern 1: Sync Faire orders to an ERP

When to use this pattern

Use this pattern when Faire Orders must become sales orders or fulfillment work items in an ERP or order-management platform. A scheduled workflow can retrieve newly created or updated Orders and their lines, while reconciliation handles missed notifications or partial failures.

Integration direction
Faire
Martini
NetSuite
Example Mapping
Faire FieldCanonical FieldTarget Field
Order IDexternalOrderIdExternal ID
RetailerbuyerAccountCustomer
Product variant IDskuOrItemReferenceItem
Order statusorderStatusOrder Status
Martini implementation pattern

Martini retrieves paginated Faire Orders using an approved REST API scope, resolves Product variant identifiers, validates customer and item mappings, and creates or updates ERP sales orders idempotently. Failed records are isolated with source identifiers and retried after transient errors; business validation failures are routed for reconciliation.

Martini capabilities used
  • workflows
  • API consumption
  • scheduling
  • data mapping
  • business rules
  • error handling

Pattern 2: Synchronize Faire products and inventory

When to use this pattern

Use this pattern when a brand needs consistent Products, Product variants, and inventory between Faire and a commerce or ERP platform. Incremental retrieval is preferred where Faire exposes timestamps, cursors, or equivalent filters.

Integration direction
Faire
Martini
Shopify
Example Mapping
Faire FieldCanonical FieldTarget Field
Product titleproductNameTitle
Product variant IDexternalSkuIdVariant SKU
Wholesale priceunitPricePrice
Inventory quantityavailableQuantityInventory
Martini implementation pattern

Martini retrieves changed Products and Product variants, transforms Faire fields into the target catalog schema, applies inventory and status rules, and performs idempotent updates using stable identifiers. Pagination checkpoints, rate-limit backoff, and a reconciliation timestamp allow the workflow to resume without duplicating catalog changes.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • transformations
  • business rules
  • retry handling

Pattern 3: Synchronize shipments back to Faire

When to use this pattern

Use this pattern when a warehouse, fulfillment application, or ERP produces shipment and tracking information for Faire Orders. The Faire partner account must have permission to submit the supported fulfillment update.

Integration direction
ShipStation
Martini
Faire
Example Mapping
Faire FieldCanonical FieldTarget Field
Order IDexternalOrderIdFaire Order ID
Tracking numbertrackingNumberShipment tracking number
CarriercarrierCodeShipment carrier
Shipment statusfulfillmentStatusFaire shipment status
Martini implementation pattern

Martini receives or retrieves completed shipment results, correlates them to Faire Orders using stable identifiers, validates carrier and tracking data, and submits the supported Faire update. Idempotency keys or shipment cross-references prevent duplicate updates, while transient API failures use bounded retries and permanent permission failures enter reconciliation.

Martini capabilities used
  • workflows
  • API consumption
  • API orchestration
  • data mapping
  • validation
  • error handling

Pattern 4: Process Faire event notifications

When to use this pattern

Use this pattern when selected Faire webhook events should trigger near-real-time enterprise processing. Because Faire event coverage may be limited, a scheduled reconciliation workflow should verify important Orders, Shipments, or inventory changes.

Integration direction
Faire
Martini
Salesforce
Example Mapping
Faire FieldCanonical FieldTarget Field
Event IDeventIdIntegration Event ID
Object IDsourceObjectIdExternal ID
Event typeeventTypeActivity Type
Object statuscurrentStatusStatus
Martini implementation pattern

Martini exposes a secured endpoint, validates the notification, records the event, and rejects duplicate event IDs before routing the current object state to Salesforce or another target. If the payload is incomplete, the workflow retrieves the resource from Faire; scheduled reconciliation identifies missed events and repairs failed processing.

Martini capabilities used
  • API exposure
  • webhook consumption
  • workflows
  • deduplication
  • data mapping
  • monitoring

Applications commonly integrated with Faire

Faire data can be integrated with adjacent commerce, ERP, accounting, fulfillment, and customer-management applications. These are practical enterprise architecture targets rather than confirmations of official Faire integrations; API access, object permissions, and write operations should be validated for the relevant Faire partner program.

Application Scenario Direction Martini Pattern
Shopify Synchronize product, variant, inventory, and wholesale order information between Faire operations and a brand’s direct-commerce storefront. Faire → Martini → Shopify Use scheduled Faire REST API workflows to retrieve Products, Product variants, and Orders, map them to Shopify models through the target API, and use stable external identifiers and reconciliation logic to prevent duplicate writes.
WooCommerce Coordinate catalog and inventory information for a brand operating a WooCommerce storefront alongside Faire. Faire → Martini → WooCommerce Consume Faire collections with pagination, transform product and variant fields into WooCommerce payloads, apply inventory rules, and retry transient failures without replaying successful updates.
BigCommerce Align product, variant, and inventory data across a brand’s BigCommerce channel and Faire. Faire → Martini → BigCommerce Run an incremental synchronization workflow using Faire timestamps or cursors where available, map SKU and identifier fields, and route validation failures to reconciliation handling.
NetSuite Create or reconcile sales orders, items, inventory, shipments, and related financial records for Faire activity. Faire → Martini → NetSuite Retrieve Faire Orders and Shipments, resolve Product variant identifiers against NetSuite items, create or update target records idempotently, and retain a cross-reference for reconciliation.
Microsoft Dynamics 365 Business Central Synchronize Faire orders, products, inventory, and fulfillment information with an ERP. Faire → Martini → Microsoft Dynamics 365 Business Central Orchestrate Faire API calls and Business Central API calls in a workflow, transform order and inventory schemas, apply account-specific write rules, and isolate failed documents for retry.
QuickBooks Online Transfer eligible order or settlement information into accounting workflows, subject to the selected Faire API program and available financial data. Faire → Martini → QuickBooks Online Retrieve authorized Faire order data, validate accounting mappings, transform totals and line information, and submit only approved transactions while recording source identifiers for duplicate protection.
ShipStation Coordinate fulfillment processing, shipping labels, and tracking updates for Faire Orders. Faire → Martini → ShipStation Send eligible Faire Orders to ShipStation, correlate fulfillment results using stable order identifiers, and submit supported shipment information back to Faire after confirming account permissions.
Salesforce Make wholesale order, retailer, brand, and account activity available to sales and service teams. Faire → Martini → Salesforce Consume Faire data through scheduled or event-driven workflows, map Retailers, Brands, Orders, and status information to Salesforce objects, and apply deduplication and business ownership rules.

How to build a Faire integration in Martini

Objective

Establish approved Faire API access and configure credentials without embedding secrets in workflow definitions.

Instructions in Martini

  • Confirm whether the integration operates for a brand, retailer, or approved technology partner
  • Confirm enabled objects, read and write permissions, API version, and partner approval requirements
  • Store Faire tokens, keys, or OAuth configuration as environment-managed secrets
  • Configure the Martini API request with the required authentication mechanism

Objective

Choose a trigger that matches the required latency and Faire event coverage.

Instructions in Martini

  • Use a scheduler for order, product, inventory, or reconciliation polling
  • Expose a Martini API endpoint for selected Faire webhook notifications
  • Use event processing together with scheduled reconciliation for business-critical data
  • Define a safe checkpoint strategy for timestamps, cursors, or processed event IDs

Objective

Read Faire resources reliably while respecting pagination and account-specific API limits.

Instructions in Martini

  • Retrieve the required Products, Product variants, Orders, Shipments, Brands, or Retailers
  • Follow Faire’s documented pagination mechanism
  • Use incremental filters or cursors where available
  • Handle rate limits, timeouts, and transient server errors with bounded retries

Objective

Coordinate Faire calls, target-system operations, enrichment, and exception paths in a maintainable workflow.

Instructions in Martini

  • Separate Faire-specific API handling from downstream business mappings
  • Retrieve additional resource state when a notification payload is incomplete
  • Apply account, status, fulfillment, and permission rules before writing
  • Persist source identifiers and processing state for recovery

Objective

Transform Faire objects into canonical and target-system schemas without losing traceability.

Instructions in Martini

  • Map Product variants to stable SKU or item identifiers
  • Map Order lines to target customer, item, quantity, price, and status fields
  • Map Shipment tracking and carrier information to the target fulfillment model
  • Validate required fields and preserve source identifiers for reconciliation

Objective

Create or update downstream records and, where authorized, submit supported updates to Faire.

Instructions in Martini

  • Use idempotent create-or-update logic for Orders, Products, variants, and Shipments
  • Confirm that the Faire account has write permission before submitting catalog, inventory, or shipment changes
  • Record target identifiers alongside Faire identifiers
  • Route validation failures to manual or automated reconciliation

Common Faire data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
BrandsRepresent suppliers that sell products through Faire and support brand-level synchronization or account context.ERP, Salesforce, product-management platformsMartini retrieves authorized Brand data, maps identifiers and attributes to target models, and applies account-specific permission and deduplication rules.
RetailersRepresent buyers that purchase from brands through Faire and support account or relationship synchronization.Salesforce, ERP, customer-management platformsMartini maps Retailer identifiers and attributes, validates required target fields, and maintains source-to-target cross-references.
ProductsRepresent wholesale products listed by a Brand, including titles, descriptions, pricing, status, and available media references where exposed.Shopify, WooCommerce, BigCommerce, ERP, product-management platformsMartini consumes paginated or incremental results, transforms product fields, and applies idempotent create or update logic.
Product variantsRepresent purchasable SKU-level options such as size, color, or other variant attributes.ERP item catalogs, commerce platforms, warehouse applicationsMartini resolves variant identifiers, maps SKU and inventory fields, and prevents duplicate item creation through stable external keys.
OrdersRepresent retailer purchases placed with brands, including order lines and referenced Product variants.NetSuite, Microsoft Dynamics 365 Business Central, ShipStation, Salesforce, order-management platformsMartini retrieves or receives eligible order information, validates lines and identifiers, creates idempotent downstream orders, and records processing status.
ShipmentsRepresent fulfillment and shipping information associated with Orders.Faire, ERP, ShipStation, warehouse and fulfillment platformsMartini correlates shipment data to Faire Orders, maps tracking and status fields, submits supported updates, and retries transient failures safely.

Authentication and security considerations

Partner approval and permissions

Faire API access may require approval or onboarding. Confirm the account role, enabled API products, object permissions, read and write access, and production credential requirements before implementation.

Credential management

Faire requests require authenticated partner credentials. Depending on the application program, access tokens, API keys, or OAuth-based authorization may apply. Store these values as Martini environment-managed secrets rather than embedding them in workflows.

Webhook protection

For selected Faire notifications, validate the authentication or signature mechanism documented for the partner integration before processing. Use HTTPS, event identifiers, replay protection where supported, and record the notification safely before acknowledging it.

Operational considerations for Faire integrations

Pagination and incremental retrieval

Process Product and Order collections using Faire’s documented pagination. Persist cursors, timestamps, or equivalent checkpoints where available, and account for records changing during a long-running synchronization.

Rate limits and retries

Handle HTTP 429 responses, transient 5xx errors, timeouts, and retry-after guidance when provided. Use bounded exponential backoff and route exhausted failures to reconciliation rather than repeatedly replaying writes.

Idempotency and reconciliation

Scheduled polling and webhook delivery can overlap. Use stable Faire identifiers, event IDs, or object/version keys to prevent duplicates. Reconcile Orders, Shipments, Products, and inventory against target systems to recover from missed notifications.

Schema and version changes

Isolate Faire-specific mappings and monitor API versions, required fields, enum values, Product variant structures, and event payload changes. Validate required fields before sending data downstream and preserve unknown fields where practical.

Testing and observability

Test with the permissions and object coverage of the actual partner account. Monitor workflow logs, API response patterns, processing checkpoints, and reconciliation outcomes.

Why use Martini instead of scripts or point-to-point integrations?

Orchestration instead of isolated scripts

Martini provides a maintainable workflow layer for calling Faire APIs, receiving selected events, transforming data, applying business rules, and coordinating multiple target systems. This avoids duplicating authentication, pagination, retries, and mapping logic across scripts.

Reusable integration assets

Faire-specific API handling, validation, identifier cross-references, and error paths can be reused across order, catalog, inventory, and shipment workflows. Martini can also expose controlled APIs for downstream applications.

Operational control

Workflows can combine scheduled synchronization with event-driven processing, persist checkpoints, handle failures, and support reconciliation. This provides a clearer operational model than unmanaged point-to-point jobs while retaining flexibility for custom logic.

Frequently asked questions

How can Faire be integrated with enterprise systems?

Faire can be integrated through its authenticated partner REST API for approved applications and integrations. Depending on account role and permissions, workflows can retrieve or manage Products, Product variants, Orders, Shipments, Brands, Retailers, and inventory. Faire also supports webhook-style notifications for selected partner events, which can be combined with scheduled reconciliation.

Can Martini integrate with Faire?

Yes. Martini can consume Faire’s authenticated REST API, expose an endpoint for supported Faire webhook notifications, schedule polling and reconciliation, transform Faire objects, and route them to ERP, commerce, fulfillment, accounting, or internal APIs. Access depends on the Faire partner approval and permissions available to the account.

Do I need a connector to integrate Faire with Martini?

No. A dedicated Faire connector is not required. Martini can integrate using Faire’s confirmed native mechanisms, primarily its partner REST API, selected webhook notifications, and the applicable authentication method configured as secure environment data.

Is there any extra Lonti cost to integrate Faire with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Faire. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Faire, cloud infrastructure providers, or other third-party systems depending on subscriptions, usage, and deployment model.

Which Faire integration methods should an architect use?

Faire’s primary method is its partner REST API, with pagination and incremental retrieval used for larger synchronizations. Webhook-style notifications are available for selected approved-partner events. No official Faire GraphQL or SOAP API was confirmed, and a general-purpose bulk or attachment API should not be assumed.

Can Faire webhook events trigger enterprise workflows?

Yes, for selected events available to the approved partner integration. Martini can expose an HTTP endpoint, validate the documented security mechanism, record event identifiers, prevent duplicates, and route notifications to downstream workflows. Event coverage, signing, retry behavior, and delivery guarantees must be confirmed with Faire.

How does synchronization between Faire and another system work?

Martini can use scheduled REST API retrieval, supported event notifications, or both. Workflows follow pagination, persist timestamps or cursors where available, map Faire identifiers to target identifiers, and use reconciliation to recover from missed events or failed processing. Orders and Shipments should use stable Faire identifiers and idempotent writes.

How are Faire API errors, retries, and duplicates handled?

Martini workflows can detect rate limits, timeouts, and transient 5xx responses, then apply bounded retries and backoff. Event IDs, object identifiers, or version keys can support duplicate protection. Validation failures and exhausted retries can be logged and routed to reconciliation or manual review without creating duplicate orders, products, or shipments.

Related Martini documentation

Faire APIs

Events

Workflows

Security

Operations

Connect Faire with your enterprise systems

Use Martini to build secure, resilient Faire integrations for orders, products, inventory, shipments, and selected event notifications.

EXPLORE MARTINI
BOOK A DEMO