1 of 18

Apps

This doc provides an overview of Ergonode Apps framework.

Apps allow you to extend the user interface of Ergonode - thanks to them you can do more in one place, eventually making handling your data and processes easier.

What's an App?

The App is a small custom web application (microservice) that resolves your business-specific problem.

It can generate a CSV file, integrate your data with an external eCommerce system, or even modify the data within Ergonode to i.e. automate some of the data management processes.

The App communicates with Ergonode through its public application programming interfaces (APIs) - you don't modify Ergonode code itself but instead provide a separate web application that, together with your Ergonode instance, removes obstacles on your path.

Since the App is a standalone application you are not limited to any specific programming language - you can develop it in PHP, Java, Python, JavaScript, and many more.

It can be written by yourself, by an agency you work with, or you can use one of the native Apps provided by the Ergonode team itself.

How can I start with the development of my custom App?

Follow this , or contact one of our trusted partners or your development agency.

Quick start

Overview of steps required to create an App

To create an App you only need basic development knowledge.

You are not limited to a specific programming language, only to the possibilities granted via Ergonode by its communication interfaces.

To develop a functional App you only need to follow a couple of simple steps.

Create a Manifest

Firstly, you need to provide a Manifest - a simple JSON file determining the basic App behavior and possibilities it is utilizing.

The file is required for the app registration process for the New App to display in your available apps tab.

Prepare authentication

Next up it's essential to keep your data safe. To achieve that you should have a functional authentication system.

The App has to be able to identify itself so that Ergonode will know it can perform the API operation it is trying to execute. It is also crucial that when the App receives a request it can determine whether it comes from a trustworthy source.

On App installation, Ergonode exchanges handshake with App with data allowing authentication of the following requests performed, assuring that no 3rd party is tempering the data.

Handle your configuration

Some Apps require dedicated configuration. Once provided by Manifest App users will be able to set up their App within Ergonode to make it work appropriately to the installation needs - App should validate and persist your configuration.

Implement event endpoints

If your App needs to know about basic events create specific events handling.

Implement your business logic

It is up to you what exactly the App will do.

Implement synchronization endpoints

This step is optional and depends on your intent.

If your App is meant to generate a file, integrate the data into the eCommerce system, or has a similar purpose forcing having the long-running process to handle all of the data, rather than implementing the entire synchronization yourself, let Ergonode orchestrate the process and focus only on the development of your business logic.

Host your application

Host your application on an HTTP server of choice.

For development and testing use tools like to make quicker code iterations.

Ergonode currently does not provide hosting for custom Apps.

Register your App

Once all set up register your App in the available apps tab.

To refresh the App Manifest, it has to be changed and reapplied just like on App registration. Ergonode does not refresh it automatically.

Remember also, on refreshment, to raise the version - otherwise, changes won't be applied as described in the restrictions description.

Detailed reference

Manifest

Full reference of Manifest file.

Manifest is a simple JSON file that describes your App behavior and its possibilities.

To refresh the App Manifest, it has to be changed and reapplied - just like on App registration. Ergonode does not refresh it automatically.

Remember also, on refreshment, to raise the version - otherwise, changes won't be applied as described in the restrictions description.

Contained fields:

Dictionaries

Extend the configuration via dictionaries

Sometimes you need to choose from a predefined list of values already existing in the system.

In the configuration, it's not always easy as the values may be related to the configuration itself. The values may be available only after configuring the API Key in step one etc, therefore, cannot be part of the regular schema.

That's where the dictionaries come in handy. There are two sources of the configuration. The data either come from Ergonode or App.

The source of the dictionary is recognized via prefixes ergonode: and app:

Ergonode

List of available dictionaries

ergonode:attributes
- it is possible to limit types of attributes thanks to query parameters - egonode:attributes?type=TEXT,TEXT_AREA
ergonode:categories

App

In App, you can define as many custom dictionaries as you require.

In Manifest you reference the dictionary by the conjunction of app: prefix and dictionary ID suffix i.e app:attributes.

App provides custom dictionaries by implementing /dictionary/{dictionary} endpoint.

For the above example, the endpoint would be /dictionary/attributes.

The dictionary endpoint will be called only when the step of the configuration schema it is defined in is generated, so you have all the configuration from earlier steps at your disposal during dictionary retrieval(like API keys, etc).

The endpoint response for the valid dictionary should return

Type validation

If your mapping requires extra type validation, you may provide type for every entry that matches the mapping context. For multiple types, separate them with |.

Merging values

By default, mapping on dictionary items allows only one value to be mapped to a specific attribute. It is possible to override this behavior by declaring the possibility of merging via allows_merging flag.

If enabled, the App is responsible for merging value itself according to internal strategy - flag only changes the behavior of the mapper, and values are provided to App the same way.

Authentication

Description of concepts behind authentication system and how to prepare your own security.

Requests between Ergonode and App are signed using tokens.

These tokens allow the safe exchange of custom data(claims) between two parties.

The token contains claims describing the context of the execution - what specific installation the token is referencing etc.

The token is always available in X-APP-TOKEN HTTP header with a signature signed using HMAC SHA-256.

Configuration

Configure your App in Ergonode

If the App requires configuration and defines configuration form in configuration_schema it has to appropriately handle the values.

It has to be able to validate and persist the configuration and also provide the configuration for reading.

To do so 2 endpoints implementation is necessary.

Each endpoint receives an appropriate X-APP-TOKEN HTTP header with JWT that allows authentication of the caller.

[GET] /configuration

The endpoint should return all so-far persisted schemas in update configuration steps in the form of an array of data - according to your schema.

For example for a simple configuration schema

the expected response would be

Every object represents single form step/one configuration schema.

Preserving the configured objects under the same indexes as their definitions in the configuration schema is mandatory.

[POST] /configuration

The endpoint accepts, validates, and persists in the configuration step.

payload

All 2xx responses will be treated as success.

Error handling

The forms are validated against configuration schema but not all validation can be performed based on JSON schema.

I.e. API token can only be verified in the App.

Though the frontend application performs configuration validation on every step it is a good practice to perform full validation in the App as well to limit any potential errors.

To assign a custom error message to specific user form fields it is required to return an error response with code 422 and the payload

All other error codes will be treated with a generic error message.

Event endpoints

React on events occurring in your App

There are several endpoints corresponding to events in the Manifest configuration.

Each endpoint receives an appropriate X-APP-TOKEN HTTP header with JWT that allows authentication of the caller.

/consume/app_installed

subscribed event:

example payload:

/consume/app_uninstalled

subscribed event:

example payload:

Synchronization endpoints

Next to App events, there are multiple Synchronization events for which there are respective endpoints to be implemented.

Synchronization

Let Ergonode orchestrate the synchronization process and worry only about your business logic

At the heart of every PIM-including ecosystem, there's data integration.

A need to keep your data well-organized thanks to PIM and easily accessible to eCommerce system(s).

We do realize that creating the synchronization process is not an easy task. At the very minimum, it most usually requires:

a queue system like RabbitMQ, Amazon SQS, etc
a worker
well-developed and robust logic to handle the process
- progress state
- both process and entry statuses
persistent storage i.e. database
business logic implementation

which is a lot and usually not that easy to do, especially, in the distributed environment of multiple services.

That's why at the core of the Apps engine we created an entire synchronization process orchestration with the intent of you only being left with implementing your desired business logic and the minimum effort needed around it.

Need only an incremental export of data you have recently changed? We've got you covered.

Does it have to handle full export each time? It's possible with an App.

Creating synchronization App

To start with a synchronization App enable at least one of those features in your Manifest.

synchronization - enables the basic integration. During every synchronization, you'll only receive data changed from the last iteration
synchronization_full - enables the possibility of running full integration on every execution

Both features may be enabled next to each other or you can pick just one.

If your App generates a file, enable features according to your needs

synchronization_file_download - enables file download for each synchronization
synchronization_file_download_latest - generates constant URL under last-generated file will be available for feed-like functionalities

Finally, you need to develop your business logic in and if your App utilizes this feature.

Data flow

Overview of the data flow during synchronization process

Synchronization start

This phase is optional based on the App subscribes to.

Status: Preparing

Synchronization endpoints

A place where the synchronization business logic is implemented

Synchronization endpoints have a very similar role to message handlers in a message queue system.

They receive the event(message) with data and react to its payload.

There are several endpoints corresponding to events in the Manifest configuration.

Each endpoint receives an appropriate X-APP-TOKEN HTTP header with JWT that allows authentication of the caller.

JWT for all synchronization endpoint requests is extended with an extra context claim synchronization_id.

This claim is a UUID and allows identification of the synchronization process.

Every endpoint should respond with a 2xx HTTP code to be treated as a success.

Synchronization endpoints

All the endpoints follow the semantic [PUT] /consume/{event}.

synchronization.events contains an array of detailed payloads containing actual changes - .

Those events allow retrieving information about what has changed and reacting to that change.

This field for DELETED events is always an empty array.

/consume/attribute_created

subscribed event:

example payload:

In the above examples, you might have noticed the resource_customs field.

This mechanic allows small pieces of information such as JSON to be stored in the engine.

The most common use case for this would be storing the ID of the eCommerce entity next to the resource. It'll be passed with every following request so it's easier for your business logic to create the requests to the eCommerce system without the need of reaching to the database.

To persist the custom in the response of the endpoint add the following payload

The resource custom will only be persisted on 2xx(non-204) HTTP responses.

Errors handling

Handling of the request payload may fail.

In such case, there are a couple of scenarios:

failed connection(including 502 and 503 HTTP errors) - the event will be retried a couple of times before aborting completely
5xx and 3xx HTTP responses
- for a single resource, the event is not retried as of an internal error and the history entry is marked with a generic message

File download endpoint

If an App purpose it to generate a file as a result of synchronization enable any of the following features based on your needs

To allow access to Ergonode for generated files you need to implement the following endpoint.

Design considerations

Good practices and tips

Security

Carefully approach multitenant Apps. Since Apps can handle multiple installations, even on multiple Ergonode instances, query your persistent data with that in mind to prevent data security leaks.

Get to know the authentication section well.

Concurrency

The App should be highly available to accept multiple requests simultaneously.

To increase the performance of the synchronization process Ergonode can send a couple of requests at one time concurrently. Not only from one instance but also during one synchronization, especially if there's a lot of data being integrated.

Use cache

If your app needs extra PIM data fetched by Ergonode APIs, especially during synchronization, cache it internally for at least the length of the process. It shall significantly speed up your processing.

Changelog

The changelog is a list of recent changes to Apps.

2025-04-10

synchronization_scheduler feature added

2024-05-14

Apps release 🎉

Breaking changes

The list of recent and upcoming breaking changes

The list of recent and upcoming breaking changes At Ergonode we strive to make your integration process as fluent as possible but from time to time we discover a flaw in the design of the schema or introduce a really cool new feature that is impossible to be provided in a fully-compatible non-breaking way.

In such a situation, we will always aim to not break your integration with the new release and provide you with a transition period of approximately 3-months to adjust your consumer. Every such change shall be communicated in the following list.

{ "name": "My custom App", "description": "My custom App description", "version": "0.1.0", "compatible": "0.0.0", "configuration_schema": [ { "title": "Connection", "type": "object", "properties": { "apiKey": { "type": "string", "title": "API key", "propertyOrder": 1 } }, "required": [ "apiKey" ] }, { "title": "Settings", "type": "object", "properties": { "setting": { "type": "string", "title": "Specific app setting", "propertyOrder": 1 } }, "required": [ "setting" ] } ], "features": [ "synchronization", "synchronization_full", "synchronization_file_download", "synchronization_file_download_latest" ], "events": [ "product_created", "product_updated", "product_deleted", "synchronization_ended", "app_uninstalled" ], "icon": "data:image/webp;base64,UklGRsAFAABXRUJQVlA4ILQFAACwLQCdASoIAQgBPpFIoEulpKMhpFb4OLASCWVu4XSZz39d84G2/0j8LdH4ePpu0QehvzAP0K/3n9P6yHmF/mHTO/2XqHf9XqQPQg6WT9h8I9/zM4Xvm7T3+A3tolr1x1F/0Vg126lTUDoHQOgdA6B0DoHQOgdA6B0DoHQOgdA6B0DoHQOgdA6B0DoHQOgdA5YhX87OLqYej4fP5yIn49Vg7edLvNQxEgQalakkLTjaZWmeCj7XffMI5IYlK0H7LlDHGTFhS6vTeEXq852czXpeRmXsxCi0hiYJG9C0UX9wFkJ6wZ03+QSxDeEXuSwN4yHW16ggnSEcEzOCjkjao/OEhI842ptUF9WjpAQeuoViARullbWalo2TJGbhF7ozRavokygEYnRBuOaQQEt+I8zEZWgn7Saf6ji042l91UXREER4l7n0b5uWuySXuk6B0DrCpKm1NqbU2ptTam1NqbU2ptTam1NqbU2ptTam1NqbU2ptTalgAAD+9lD2Zb//9dx/53H/ncZmgmWCEYsIAAAABy+r8RtwslSEv0snvKmjf+wInhYkZ69wA2wOi6vvlXllaLZ/sfosQCfzDV3EhuLH28SIxv98IkoczaEb3+Pl/8lD7E5cjhfvtAqKX91uhXb/8+/jjTWZYnNDQcQpn7Qffa8BGDhmqHf/M7cbE1vw/J5Kvr6Ds9cY1vA/6oJs/W/ARFbYq46Wx7Cmni4CYRb9V7U2kNsAddu0pNKwqOmkJpIX91ey5qNB4dRRyvDmAMF8ftrTHLXBJXZvtFHIIQOWL8iyHGTBt7DyAeLbHpUatyM+BJPKf8P1fA/HxZ9ats9DiutJzmji9J0V68O26e8IJEfNt7aZe2yLrDPDpGUk/2hf+HncO7gxhdoMOUgx2pMGdkYG4lVEZM0RL3QQcS4F1rN5z+6DmeJ5QhrmEbZuomukKdaYrwLcEQOV4RJ2exJt2rh6tC7Vn1ghzf8Ju3d+zm0AU79dzF3aVBmQMgP7MJ+Jxyb3ZCnuWtoG+o1hIs3/UTjIAYfTcrU2YC0/tamgX46tYj/3wTjU73Foj+ihuOQfk0Jo1GjTBMU8mnJ4A2JMmrIPKskquNRO09Kyo64HIvPDuggb8efQoVvLEyvn1wKzChX5nmvAENOVMBlHEsM+1b4h+8+v+W9Drw9X8o1wL04LfPxnBlY/8hYE3j1tlvjbo0J3YuV4Ih8vfSb63IcJmPYhRdHXavcpv+WMVV//86gH9wjqzpqdZG+Twfz722biI4aGAxGfeH/O/CILnplEgyXU0eySpNflC2JJso1d5Eyiue8eMje4XM65KS/8Kz16F2wYJgGfjlC+YgYXnlaX8x29FYeIiWivNG3zvahM5k3LTiE90cgsZnPH0rCLRe8OuHIFGfeWCv7exWhddIf3YekuFg4n+HY999JzYmmgFBwooH/lM16Z/MdSU7JG9ahFC4ywu0MxIfhQyOSvt05rW6ts7L6QmJ+gFjKsod3FudEjADbQHjhVN/Gb1KtyknKXXrTr6hmgEuFb3TD0tyv4MXxJuoTaeiWcygV7WMVtJWfb80UcJ4f+NQe7OJp5P7H7w5e4jMSIMbQFGEkyOzi0xw+FFdOso6ZQaqqBdqeCB9Z9TdrQDwdfihNr4H+BGO4xrdLk3jAGRACNjN+yBZx5TYeRjWTDFZXpnnUlECHlvCzRtWAuZf19qOKzDsy4ypJ/N28ilq4e9TEykVocV5tnf5pGcHSza3EAWyBrWTEPj7k3JetvhbuASW2M2BRBZk+GtI3RsTSYQnWV77fANxGp1vIufGmRj/QxF9w1umS/BUIpkt9TAArXG6USpH7V9AFA377J8BS6p8wMUmcsHCymFOuM1l0BnEnGP+o13bk9uwHkx2k4g6AMXR6ZnnzdQhlB0lsHhdGROJnO3dxQgKhcojXvVPlrLX8whSU6gAAAAAAAAA==" }

Configuration schema

Overview of how to build App configuration

Introduction

App most usually requires some sort of configuration specific to its installation.

Below you can find the Ergonode CSV App configuration.

Such configuration can be achieved by setting up the configuration_schema section in the Manifest file.

The value is a list of allowing you to build a form.

Not full JSON Schema is yet covered in Ergonode.

If you have a case of a feature that suits your needs and is a part of the JSON Schema standard we may consider extending our implementation.

Please contact the respective Ergonode representative with the details.

The reason it's a list is fairly simple - in some scenarios, at first you need to input i.e. API Token, then choose which attributes from the App you'd want to configure - a piece of information that is only accessible once authorized within the system App is handling.

So the following steps in the form(following JSON Schemas) will be built once you correctly fill the current step.

Example schema

Ok, so a lot is going on in this example. Let's break it down field by field.

simpleText

This is the simplest case.

It's a plain text that your user can input. It'll be displayed as a regular HTML text input.

secret

The secret is very similar to the previous simple text example but as with any other sensitive data you do not always want it visible constantly on your configuration. That's why a is added - it results in a hidden secret text.

multilineText

Sometimes one-line text won't suffice. You can extend the text presentation thanks to the .

simpleEnum

Another frequent case is a limited of values from which a user can choose. That's where the enum comes into play. There are 2 additional special fields added here

enum - represents the actual valid value list to choose from
options.enum_titles - represents the presentational titles list to be displayed to the user in dropdown

enumMultiple

An extended example of simple enums is when you have multiple choice allowed. Instead of using type string adjust it to array with string type elements.

dictionaryErgonodeEnum

Here's where things get a bit more kinky. You, again, need a predefined set of values but those values are already there in Ergonode i.e. a list of languages to choose from or an attribute.

A field options.enum_dictionary is added - in short, you tell the interpreter to render a list of languages from Ergonode via a dictionary ergonode:languages - this is resolved by Ergonode.

dictionaryAppEnum

Another possibility is that the predefined list is not part of Ergonode data but the App or system it integrates with. The App may define multiple dictionaries with different data.

Note this time options.enum_dictionary is wrapped into items - this changes the select to multi-select in the dropdown list.

attributeMapping

Occasionally, especially on synchronization Apps, you'll need attributes mapping from Ergonode to an external system. This is possible by combining two things.

A structure definition that can carry on the mapping

and capable of making it easier to map the data in the configuration user interface.

Widgets

Widgets are dedicated UI components that allow a custom presentation of a specific field.

password

Changes displaying of the plain text in HTML text input into password input.

textarea

Presents text input in the form of textarea input.

mapper

Allows for drag-and-drop mapping of the attributes and handles validation of their types.

The widget accepts 2 options:

ergonodeDictionary - saying where from claim data - this option is mandatory
appDictionary - this field is optional - if not present the Ergonode mapping will be possible to textual values

{ // (...) rest of the Manifest file "configuration_schema": [ { "title": "Configuration", "type": "object", "properties": { "simpleText": { "type": "string", "title": "Just a text", "propertyOrder": 1 }, "secret": { "type": "string", "title": "Secret password", "widget": "password", "propertyOrder": 2 }, "multilineText": { "type": "string", "title": "Multiline text", "widget": "textarea", "propertyOrder": 2 }, "simpleEnum": { "type": "string", "title": "Simple Enum", "enum": [ "1", "2" ], "options": { "enum_titles": [ "one", "two" ] }, "propertyOrder": 4 }, "enumMultiple": { "items": { "type": "string", "enum": [ "one", "two" ], "options": { "enum_titles": [ "Choice one", "Choice two" ] } }, "minItems": 1, "uniqueItems": true, "type": "array", "title": "Multiple choice enum", "propertyOrder": 6 }, "dictionaryErgonodeEnum": { "type": "string", "title": "Dictionary Ergonode Enum", "options": { "enum_dictionary": "ergonode:languages" }, "propertyOrder": 7 }, "dictionaryAppEnum": { "type": "string", "title": "Dictionary App Enum", "items": { "type": "string", "options": { "enum_dictionary": "app:app-dictionary" }, "minItems": 1, "uniqueItems": true }, "propertyOrder": 8 }, "attributeMapping": { "type": "array", "title": "Attribute mapping", "items": { "title": "prototype", "type": "object", "properties": { "ergonode": { "type": "string", "title": "ergonode", "propertyOrder": 1 }, "app": { "type": "string", "title": "app", "propertyOrder": 2 } }, "required": [ "ergonode", "app" ] }, "widget": { "type": "mapper", "options": { "ergonodeDictionary": "ergonode:attributes", "appDictionary": "app:attributes" } }, "propertyOrder": 9 } }, "required": [ "simpleText", "secret", "multilineText", "simpleEnum", "enumMultiple", "dictionaryErgonodeEnum", "dictionaryAppEnum", "attributeMapping" ] } ] }

{ "type": "object", "properties": { "type": { "type": "string", "description": "The type of synchronization event." }, "payload": { "type": "object", "description": "The detailed payload of the synchronization event.", "properties": { "attribute_code": { "type": "string" }, "attribute_type": { "type": "string", "enum": ["DATE", "FILE", "GALLERY", "IMAGE", "MULTI_SELECT", "NUMERIC", "PRICE", "PRODUCT_RELATION", "SELECT", "TEXT_AREA", "TEXT", "UNIT"] }, "attribute_scope": { "type": "string", "enum": ["local", "global"] }, "value": { "oneOf": [ { "type": "string", "description": "For global attribute of type DATE, SELECT, TEXT_AREA and TEXT" }, { "type": "number", "description": "For global attribute of type NUMERIC, PRICE and UNIT" }, { "type": "array", "items": { "type": "string" }, "description": "For global attribute of type MULTI_SELECT and PRODUCT_RELATION" }, { "type": "object", "properties": { "url": { "type": "string" }, "path": { "type": "string" } }, "required": [ "url", "path" ], "description": "For global attribute of type IMAGE" }, { "type": "array", "items": { "type": "object", "properties": { "url": { "type": "string" }, "path": { "type": "string" } }, "required": [ "url", "path" ] }, "description": "For global attribute of type FILE and GALLERY" }, { "type": "array", "items": { "type": "object", "properties": { "language": { "type": "string" }, "value": { "oneOf": [ { "$ref": "#/components/schemas/AttributeValue" } ] } }, "required": [ "language", "value" ] }, "description": "For local attributes same types as for global wrapped in translation array" } ] } }, "required": [ "attribute_code", "attribute_type", "attribute_scope", "value" ] } }, "required": [ "type", "payload" ] }

Apps

Apps

hashtagWhat's an App?

hashtagHow can I start with the development of my custom App?

Quick start

hashtagCreate a Manifest

hashtagPrepare authentication

hashtagHandle your configuration

hashtagImplement event endpoints

hashtagImplement your business logic

hashtagImplement synchronization endpoints

hashtagHost your application

hashtagRegister your App

Detailed reference

Manifest

Dictionaries

hashtagErgonode

hashtagApp

hashtagType validation

hashtagMerging values

Authentication

Configuration

hashtag[GET] /configuration

hashtag[POST] /configuration

hashtagError handling

Event endpoints

hashtag/consume/app_installed

hashtag/consume/app_uninstalled

hashtagSynchronization endpoints

Synchronization

hashtagCreating synchronization App

Data flow

hashtagSynchronization start

Synchronization endpoints

hashtagSynchronization endpoints

hashtag/consume/attribute_created

hashtag/consume/attribute_updated

hashtag/consume/attribute_deleted

hashtag/consume/category_created

hashtag/consume/category_updated

hashtag/consume/category_deleted

hashtag/consume/product_created

hashtag/consume/product_updated

hashtag/consume/product_deleted

hashtag/consume/synchronization_started

hashtag/consume/synchronization_ended

hashtagResource customs

hashtagErrors handling

File download endpoint

Design considerations

hashtagSecurity

hashtagConcurrency

hashtagUse cache

Changelog

Changelog

hashtag2025-04-10

hashtag2024-05-14

Breaking changes

Quick start

hashtagCreate a Manifest

hashtagPrepare authentication

hashtagHandle your configuration

hashtagImplement event endpoints

hashtagImplement your business logic

hashtagImplement synchronization endpoints

hashtagHost your application

hashtagRegister your App

Dictionaries

hashtagErgonode

hashtagApp

hashtagType validation

hashtagMerging values

Apps

hashtagWhat's an App?

hashtagHow can I start with the development of my custom App?

Authentication

hashtagHandshake

hashtagAuthentication of the incoming request

hashtagAuthenticate the request to Ergonode

Manifest

What's an App?

How can I start with the development of my custom App?

Create a Manifest

Prepare authentication

Handle your configuration

Implement event endpoints

Implement your business logic

Implement synchronization endpoints

Host your application

Register your App

Ergonode

App

Type validation

Merging values

[GET] /configuration

[POST] /configuration

Error handling

/consume/app_installed

/consume/app_uninstalled

Synchronization endpoints

Creating synchronization App

Synchronization start

Synchronization endpoints

/consume/attribute_created

/consume/attribute_updated

/consume/attribute_deleted

/consume/category_created

/consume/category_updated

/consume/category_deleted

/consume/product_created

/consume/product_updated

/consume/product_deleted

/consume/synchronization_started

/consume/synchronization_ended

Resource customs

Errors handling

Security

Concurrency

Use cache

2025-04-10

2024-05-14

Create a Manifest

Prepare authentication

Handle your configuration

Implement event endpoints

Implement your business logic

Implement synchronization endpoints

Host your application

Register your App

Ergonode

App

Type validation

Merging values

What's an App?

How can I start with the development of my custom App?

Handshake

Authentication of the incoming request

Authenticate the request to Ergonode

description

version

compatible

configuration_schema

features

synchronization

synchronization_full

synchronization_file_download

synchronization_file_download_latest

synchronization_scheduler

events

app_installed

app_uninstalled

attribute_created

attribute_updated

attribute_deleted

category_created

category_updated

category_deleted

product_created

product_updated

product_deleted