• Documentation >
• Product catalog >
• Quable PIM integration >
• Install Quable

Install Quable connector

To integrate Ibexa DXP with Quable PIM, you need to install the Quable connector packages, configure the connection, and set up synchronization.

Create Quable instance

Before installing the Quable connector, ensure you have access to a Quable PIM instance.

Install packages

Run the following commands to install the required packages:

composer require ibexa/quable-client
composer require ibexa/connector-quable

These commands add the Quable connector code, including services that enable communication with Quable PIM.

Get API credentials

To connect to Quable PIM, you need an API token:

1. Log in to your Quable instance (for example, https:/example.quable.com).
2. Navigate to the API Tokens section
3. Copy the Read Access Token value for use in the configuration.

Configure Quable connector

In config/packages/ibexa_connector_quable.yaml, specify the configuration for the Quable connector:

ibexa_connector_quable:
    instance_url: 'https://example.quable.com'
    api_token: '<your_api_token>'
    channel_code: '<channel_code>'

Replace <your_api_token> with the Read Access API token you obtained from Quable in the previous step.

Quable's channels allow you to distribute your product information to defined recipients, for example e-commerce platforms. Select the Quable channel you want to integrate with Ibexa DXP.

For all available configuration options, see Configure Quable.

Configure product catalog engine

To use Quable as the product data source, configure Ibexa DXP's product catalog to use the Quable engine.

Define Quable engine

In config/packages/ibexa_product_catalog.yaml, add a new engine configuration:

ibexa_product_catalog:
    engines:
        local:
            type: local
            options:
                root_location_remote_id: ibexa_product_catalog_root
                product_type_group_identifier: product
        quable:
            type: quable
            options:
                taxonomy: quable
                root_location_remote_id: ibexa_product_catalog_root
                product_type_group_identifier: product

This configuration defines two engines: the default local engine and the new quable engine, allowing you to work with products defined within Quable.

To learn more about product catalog configuration, see Product catalog configuration.

Set Quable as default engine

In your repository configuration, typically in config/packages/ibexa.yaml, configure the product catalog to use the Quable engine as the product data source:

ibexa:
    repositories:
        default:
            storage: ~
            search:
                engine: '%search_engine%'
                connection: default
            product_catalog:
                engine: quable
                regions:
                    default: ~

Set up languages

To use the products from Quable within Ibexa DXP content, make sure the data languages in {{ product_pim }} have corresponding languages in Ibexa DXP.

To preview the current language configuration in both systems, run the following command:

php bin/console ibexa:quable:languages:check

Based on the returned data, adjust the language configuration as your use case requires.

Synchronize taxonomy

After configuring the integration, synchronize product classifications from Quable to Ibexa DXP's taxonomies.

Run the following command to synchronize classifications:

php bin/console ibexa:quable:classification:sync

This command imports the product classification structure from Quable PIM into Ibexa DXP, ensuring that product categories are aligned.

Tip

To keep the classifications aligned, we recommended to run the ibexa:quable:classification:sync command very night, even when using synchronization with webhooks.

Set up real-time synchronization

Quable PIM can notify Ibexa DXP about product data and classification changes in real-time using webhooks. This invalidates the cache kept in Ibexa DXP and ensures that product information stays up to date.

Webhook configuration requires setup in both Quable PIM and Ibexa DXP.

Create webhook in Quable

1. Create a new webhook in Quable.
2. Set the webhook's code (used as the webhook's name)
3. Provide the URL to your Ibexa DXP instance suffixed by /webhook/quable, for example: https://example.com/webhook/quable
4. Mark it as Activated
5. Enter a secret value for the Authorization Header

6. Choose the following scopes:

7. Products: created, updated, deleted

8. Classifications: created, updated, deleted

The Authorization Header value is a secret that must be kept secure.

Note

For local development and testing, you can consider using one of the avalable tunnel providers to make your local instance accessible.

Configure webhook in Ibexa DXP

In config/packages/ibexa_connector_quable.yaml, specify the configuration for the Quable connector:

ibexa_connector_quable:

    # Existing configuration (...)

    webhook_secret: '<webhook authorization header>'

Warning

Quable uses dynamic IP addresses) to connect to Ibexa DXP. If your DXP instance is protected by a firewall, make sure your configuration allows connections from changing IP addresses.

Configure background task

Ibexa DXP's webhook processes Quable's classification change events and queues them to be processed in the background.

To process them, configure Ibexa Messenger and make sure the messenger:consume command is run periodically.