Custom Product Integration

The Custom Product Integration connects a product information system, ERP, data platform, or other catalog source to Endless through the GraphQL API. It provides controlled read and write access to product data, including supported attributes, media, pricing, composition, external identifiers, and inventory workflows.

This guide explains the integration's role, setup, and recommended operating model. The API reference is the source of truth for available operations, arguments, fields, types, and response shapes.

When to use it

Use a Custom Product Integration when another system needs to create or maintain product information in Endless. Common uses include:

• importing a catalog from a product information management system or ERP
• keeping product attributes, pricing, or media synchronized
• associating Endless products with stable identifiers from another system
• updating inventory through a custom catalog or inventory workflow

This integration is intended for product-related workflows. Use a Custom Sales Integration for externally sourced orders, a Custom Fulfillment Integration for warehouse fulfillment, or a Custom Data Integration when a system only needs to read data.

The API reference is the source of truth

Use this guide to understand the workflow and use the API reference to build against the current schema. Do not infer operation names, required inputs, or field behavior from examples outside the API reference.

Decide what each system owns

Before building the connection, decide which system is responsible for each part of the product record. For example, one system might own core catalog details while Endless owns operational attributes or inventory.

Document these decisions before syncing data:

• which system creates new products
• which fields the external system may overwrite
• which identifier connects the same product across both systems
• how archived, deleted, or discontinued products should be handled
• whether inventory is managed by this integration or another source
• how media, attributes, prices, and composed products should be ordered during sync

Avoid having multiple systems write the same fields without a clear ownership rule. Competing updates are difficult to diagnose and can cause the systems to repeatedly overwrite one another.

Create the integration

You need permission to manage integrations for your company.

1. In Endless, open Integrations.
2. Select Add integration.
3. Under Custom Integrations, select Custom Product Integration.
4. Give the integration a name that identifies the connected system.
5. Select Create & generate credentials.
6. Save the generated credentials in a password manager or secrets vault before closing the window.

Endless generates an access token, API key, and API secret. The access token is the credential used to authenticate the GraphQL requests described in this guide. The API key and API secret are only displayed when the integration is created or its credentials are regenerated, so save all three values when they are shown.

Create a separate integration for each external system when practical. This makes it possible to rotate or revoke one connection without interrupting another.

Connect to the GraphQL API

Send GraphQL requests as HTTP POST requests to the endpoint shown with the integration. The production endpoint is:

https://api.endlesscommerce.com/graphql

Include these headers with every request:

Header	Value
Content-Type	application/json
X-EC-Access-Token	The integration's access token
X-Company-Id	Your Endless company ID or handle

Do not add Bearer before the value in X-EC-Access-Token.

Test the connection

Use a schema-independent query to check the endpoint, credentials, and company context:

curl --request POST \
  --url https://api.endlesscommerce.com/graphql \
  --header 'Content-Type: application/json' \
  --header 'X-EC-Access-Token: YOUR_ACCESS_TOKEN' \
  --header 'X-Company-Id: YOUR_COMPANY_ID' \
  --data '{"query":"query ConnectionCheck { __typename }"}'

A successful response includes "__typename": "Query". This confirms the connection, but it does not validate a particular product operation.

Build the synchronization workflow

A reliable product integration usually follows this sequence:

1. Read the relevant product operations and types in the API reference.
2. Match records using a stable external identifier rather than a product name.
3. Create any required definitions or related records before the product data that depends on them.
4. Create or update the product using only the fields owned by the source system.
5. Store the Endless identifier returned for the product.
6. Synchronize related attributes, media, pricing, composition, or inventory using the operations documented for those resources.
7. Record the result and retry only failed work.

Do not treat every product as new on every run. A retry or scheduled synchronization must be able to recognize a record that has already been processed.

Plan the initial and ongoing syncs

For an initial catalog load, begin with a small representative set of products. Verify identifiers, attributes, media, and inventory before increasing volume.

For ongoing synchronization:

• process records that changed since the last successful run
• use supported batch operations only when the API reference recommends them
• send variables separately from the GraphQL query
• respect dependencies between products and related records
• keep a checkpoint so interrupted work can resume safely
• run periodic reconciliation to find records that were missed or changed manually

Handle errors and partial updates

GraphQL responses can contain data, errors, or both. Always inspect errors before marking work successful.

If a multi-step product sync fails partway through, retry the failed step rather than recreating the entire product. Store enough context to identify the external record, Endless record, operation, request time, and sanitized error response. Never log the integration credentials.

Protect and rotate credentials

Store credentials in a secrets vault or password manager and use them only from a trusted server or data platform. Never place them in browser code, source control, logs, or support messages.

To rotate credentials, open the integration in Endless and select Regenerate credentials. The previous credentials stop working immediately, so deploy the new access token to the connected system as part of the same change.

Troubleshooting

Problem	What to check
The request is unauthorized	Confirm that X-EC-Access-Token contains the access token with no Bearer prefix and that the credentials have not been regenerated.
The connection test works but a product operation fails	Compare the operation and variables with the current API reference and confirm that all required related records exist.
Products are duplicated	Match records using a stable external identifier and make retries safe before processing more data.
Some fields do not update	Confirm that the operation supports those fields and that the source system is intended to own them.
A large sync is slow or unreliable	Use smaller pages or batches, process incrementally, and checkpoint completed work.
A field is null	Check whether it is nullable in the API reference and whether the underlying product contains that information.

Getting help

Endless Support can help with access, credentials, company scope, and behavior that does not match the current API reference. Designing field mappings, synchronization logic, data cleanup, or a production connector is the responsibility of your technical team or implementation partner.

When reporting an API problem, include the integration name, request time and time zone, GraphQL operation name, sanitized query and variables, company handle, and the error response. Never include credentials.