> For the complete documentation index, see [llms.txt](https://docs.akinon.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.akinon.com/tutorials/omnitron/sales-channels/content-management/how-to-configure-merchant-feed-adapter.md).

# How to Configure Merchant Feed Adapter?

This document provides a comprehensive guide for configuring and managing **Merchant Feed Adapters** within the **Omnitron**, an essential tool for exporting structured product data to external platforms.

Merchant feeds are used to display products on comparison shopping engines, search engines, or affiliate platforms—allowing users to view product details, prices, and availability without visiting the brand’s actual e-commerce site. To support this, Omnitron enables merchants to generate and customize **XML feed files** based on their own schema requirements, language preferences, pricing lists, and filtering logic.

Whether you are creating a feed for a single market or managing a complex multi-language, multi-region catalog, this tutorial walks you through:

* Setting up new feed adapters through the Omnitron
* Structuring feed content using `schema_data`
* Mapping product attributes with flexible rule-based logic
* Filtering the feed by SKU or base code using uploaded files
* Managing multiple feeds by language and pricing combinations
* Manually or automatically triggering feed generation
* Controlling which category is exported for each product
* Accessing the final XML output via a generated file URL
* Troubleshooting missing or incorrect feed fields

By the end of this guide, you will be able to confidently configure and launch feeds that are optimized for your sales channels, meet third-party specifications, and scale across multiple locales with ease.

## <mark style="color:red;">Add Merchant Feed Adapter in Omnitron</mark>

To begin creating a Google Merchant Feed Adapter, follow the steps below.

### <mark style="color:red;">Navigate to the Feed Adapter Section</mark>

{% stepper %}
{% step %}
Go to **Sales Channels > Content Management > Google Merchant Feed Adapter.**
{% endstep %}

{% step %}
From this page, you can **view existing adapters**, **edit them**, or **add new ones**.
{% endstep %}

{% step %}
Click on **“+ New Google Merchant Feed Adapter”** to open the adapter creation form.

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2F5hgYtYK50JCBmgswTMie%2Fimage.png?alt=media&amp;token=724a5efe-5116-42a8-86bf-da130861c107" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

### <mark style="color:red;">Fill in Basic Adapter Settings</mark>

{% stepper %}
{% step %}
At the top of the page, you’ll see a set of core fields to define the adapter:

| Field            | Description                                                                                                                                                                                                                                               |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**         | <p>A unique name for the feed adapter. This is used to distinguish between different feeds, especially in multi-language or multi-region setups.<br><em>Example:</em> <code>insider</code>, <code>google\_feed\_en</code>, <code>feed\_ar\_uae</code></p> |
| **Adapter Type** | Defines which adapter class will handle feed generation. Select `base` unless your project includes a custom implementation.                                                                                                                              |
| **Status**       | Set this to `Active` to allow the adapter to be used during scheduled or manual feed generation. If set to `Passive`, it will be ignored by automatic processes.                                                                                          |
| **One time**     | Check this box if you want the feed to only be triggered manually. This disables scheduled executions.                                                                                                                                                    |
| **File URL**     | This field is automatically filled after feed generation. It provides a direct link for the generated XML file.                                                                                                                                           |
| **Choose File**  | (Optional) Upload a filter file in `.csv` or `.xls` format. The system will convert it to base64. The file should contain `sku` or `base_code` headers to restrict which products are included in the feed.                                               |

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2FHA1lFmGN0qFAs4s3bSnx%2Fimage.png?alt=media&amp;token=680646ae-2f88-458d-a793-d6e9eebdb425" alt="" width="438"><figcaption></figcaption></figure>
{% endstep %}

{% step %}
If you're generating feeds for multiple markets, it's a best practice to name the adapter accordingly (e.g., `google_feed_ar_ksa`) and define separate adapters per language/price list.
{% endstep %}
{% endstepper %}

### <mark style="color:red;">Configure Feed Schema (</mark><mark style="color:red;">`config`</mark> <mark style="color:red;">field)</mark>

Once the basic adapter settings are filled, the next critical step is configuring how the feed will be generated. This is done through the **`config` field**, which is a JSON object that defines the structure, behavior, and formatting rules for the XML file that will be generated.

This configuration directly determines:

* Which product attributes are included
* What the output file is named
* How images, categories, and language-specific values are handled
* Whether out-of-stock products are shown
* How visual content (like cropped images or additional images) is formatted

#### Example Configuration:

```json
{
  "chunk_size": 10000,
  "schema_data": [
    {
      "tag": "description",
      "attr_type": null
    },
    {
      "tag": "g:gender",
      "attr_type": null,
      "default_value": "Default"
    },
    {
      "tag": "title",
      "attr_type": null,
      "default_value": "title"
    }
  ],
  "EXTRA_IMAGES": true,
  "feed_filename": "insider/insider-feed_en.xml",
  "IS_ALL_SMALL_IMAGE": true,
  "url_attribute_data": null,
  "THUMBNAIL_CROP_TYPE": "Center",
  "extra_image_configs": [
    {
      "tag_name": "g:image_link",
      "tag_option": {
        "crop": "Center",
        "width": 1080,
        "height": 1080
      }
    }
  ],
  "IS_REQUIRED_SMALL_IMAGE": true,
  "category_attribute_data": [
    "category_name_en-us"
  ],
  "include_stock_out_products": true,
  "price_list_id": 1,
  "stock_list_id": 3,
  "category_name_translate_key": "category_name_en-us",
  "MERCHANT_FEED_VISILABS_IMAGE_TAG": "g:additional_image_link",
  "MERCHANT_FEED_VISILABS_IMAGE_SIZE": {
    "crop": "Center",
    "width": 1080,
    "height": 1080
  },
  "CUSTOM_CATEGORY_MAPPING_ENABLED": true,
  "category_ids_dict": {
    "00010001": "custom category id"
  },
  "category_dict": {
    "00010001": "custom category name"
  }
}
```

#### Explanation of Key Fields:

All of these keys go into the adapter's `config` field — the JSON object shown above. Key names are **case-sensitive**; write them exactly as listed. `OFFER_SHOW_LISTING_KWARGS`, mentioned further down, is a dynamic setting rather than a `config` key.

| Field                                 | Default                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `attribute_name_for_related_products` | not set                             | <p>PersonaClick adapter types only. Name of the product attribute that holds the products to recommend together with the product, separated by commas. Each value must be the related product's <code>id\_type</code> field (e.g. its SKU when <code>id\_type</code> is <code>sku</code>). The values are written into the product's <code>\<offer></code> as an <code>\<accessories></code> tag, in the order they are entered and with duplicates removed. If the attribute is missing or empty, the tag is omitted. The values must match the <code>id</code> of the related products' <code>\<offer></code> tags in the same feed.<br><em>Example:</em> with <code>"attribute\_name\_for\_related\_products": "personaclick\_accessories"</code> and the attribute value <code>"5574, 131"</code>, the offer gets <code>\<accessories>\<accessory id="5574">\</accessory>\<accessory id="131">\</accessory>\</accessories></code>.</p>                   |
| `category_attribute_data`             | `null`                              | List of category-related product attributes. These are used when building the product's category tree or name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `category_dict`                       | `{}`                                | <p>Dictionary to override <code>\<category\_name></code> based on category <code>path</code> value.<br>Format: <code>"{path}": "custom\_name\_value"</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `category_ids_dict`                   | `{}`                                | <p>Dictionary to override <code>\<category\_code></code> based on category <code>path</code> value.<br>Format: <code>"{path}": "custom\_code\_value"</code><br>See: <a href="https://apidocs.akinon.com/commerce-openapis/data-warehouse/catalogs">Getting category path information</a></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `category_name_translate_key`         | `null`                              | Attribute key used to get the translated category name (e.g., for localized feeds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `chunk_size`                          | `10000`                             | Number of products written per chunk. **Leave it at the default.** Raise it only if a feed run fails with *Chunk count is too high*; never lower it. See **Large Catalogs and Multipart Upload** for why lowering this value breaks the upload.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `CUSTOM_CATEGORY_MAPPING_ENABLED`     | `false`                             | Enables manual category mapping by path. If set to `true`, feed category values can be overridden using `category_ids_dict` and `category_dict`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `duplicate_fields`                    | not set                             | <p>Copies the value of an existing tag into a new tag under a different name. Accepts a list of <code>{"source": ..., "target": ...}</code> objects. The duplication runs <strong>after</strong> all other tags are generated, so the target always mirrors the final value of the source.<br><em>Example:</em> <code>\[{"source": "g:sale\_price", "target": "sale\_price"}]</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `exclude_arguments`                   | `null`                              | <p>Removes products matching the given product-attribute conditions from the feed. Accepts a single condition object or a list of them.<br><em>Example:</em> <code>{"attributes\_\_no\_feed": true}</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `exclude_operator`                    | `"or"`                              | Combines multiple `exclude_arguments` conditions. Accepts `"or"` or `"and"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `extra_image_configs`                 | `[]`                                | Defines how extra images (e.g., `g:image_link`) should be rendered, including size and crop strategy.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `EXTRA_IMAGES`                        | `false`                             | Enables inclusion of first product image in the feed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `feed_filename`                       | `google/feed.xml`                   | Path + filename for the output feed. This should be unique per language/market.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `INCLUDE_CATEGORY_HIERARCHY`          | `true`                              | Emits the `<c:category_hierarchy>` tag holding the same category path as numeric category IDs. Set to `false` to omit the tag; `<g:product_type>` is unaffected.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `include_stock_out_products`          | `false`                             | If `true`, includes products that are out of stock.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `IS_ALL_SMALL_IMAGE`                  | `false`                             | Ensures small image versions are used where applicable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `IS_REQUIRED_GTIN`                    | `true`                              | Writes the product SKU into `<g:gtin>`. Set to `false` to write it into `<g:mpn>` instead.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `IS_REQUIRED_SMALL_IMAGE`             | `false`                             | Forces the presence of small-sized images in the feed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `MERCHANT_FEED_VISILABS_IMAGE_SIZE`   | `{"width": "330", "height": "495"}` | Image dimensions and crop settings used for Visilabs-specific image feeds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `MERCHANT_FEED_VISILABS_IMAGE_TAG`    | `c:cropped_image_link`              | Specifies the tag under which additional images for Visilabs integration are exported.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `price_list_id` / `stock_list_id`     | `null`                              | Used to pull price and stock info from specific price/stock lists configured in Omnitron. Useful for multi-market feeds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `product_types`                       | `["simple"]`                        | List of product types to export. Accepts `"simple"` and `"offer"`, alone or together. See the **Including Marketplace Offer Products** section.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `schema_data`                         | `null`                              | List of tags to be included in the feed. Each item defines one XML tag. Optionally include a `default_value` if the mapped attribute is missing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `THUMBNAIL_CROP_TYPE`                 | `null`                              | Cropping strategy for image thumbnails. Options may include `Center`, `Top`, `Bottom`, etc.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `url_attribute_data`                  | `null`                              | Usually null unless custom logic is used for URL mapping.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `use_listable_variant_url`            | `false`                             | <p>Set on the adapter's config alongside the other options above (e.g. <code>chunk\_size</code>, <code>url\_attribute\_data</code>). When <code>true</code>, for a product where <code>is\_listable</code> is <code>false</code>, the generated product URL uses the listable parent/sibling product instead of the product's own page; query string parameters (color, seller\_id, etc.) still come from the variant itself. If no listable parent/sibling can be found, it falls back to the product's own URL.<br><em>Required together with:</em> enabling this means multiple variants can share the same base URL, so you must also add the attribute(s) that distinguish the variant (e.g. <code>color</code>, <code>size</code>) to <code>url\_attribute\_data</code> above, and define a matching <code>GoogleMerchantAttributeMapper</code> for each one. Without both, variants may end up with the same, non-differentiated URL in the feed.</p> |

### <mark style="color:red;">Category Selection for</mark> <mark style="color:red;">`g:product_type`</mark>

The feed resolves one category for each product — its **main category**, selected as described in *Which Category Wins When a Product Belongs to Several Categories* below. It appears as that category's full path, excluding the tree root, with levels separated by `>`. The path always ends with the selected category's own name; only its ancestors are trimmed.

For a product whose main category is `Towel` in the tree `Shop > Bathroom > Towel`:

```xml
<g:product_type>Bathroom &gt; Towel</g:product_type>
<c:category_hierarchy>3852 &gt; 3854</c:category_hierarchy>
```

`<c:category_hierarchy>` carries the same path as numeric category IDs. Set `"INCLUDE_CATEGORY_HIERARCHY": false` in the `config` field to omit it; `<g:product_type>` is unaffected. That key is listed under **Explanation of Key Fields** above. The adapter-specific keys named in the table below apply only to the adapter types shown beside them.

On the adapter types that emit the standard pair, a product assigned to no category is still exported, but neither tag is written.

#### Tag Names Depend on the Adapter Type

Every adapter type selects the same category, but they do not all write it into the same tag, and a few trim the path differently or emit categories beyond the selected one. The `base` adapter type and 26 others emit the `<g:product_type>` + `<c:category_hierarchy>` pair shown above. Check this table before you rely on a tag name.

| Adapter Type                                                                                                                                                                                                                                                                                    | Category output                                                                                                                                                                                                                    |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><code>base</code> and 26 others<br><em>(a101, adl, aydinli, base\_brendfoni, brandys, coco, etatpur, evidea, faraway, gant, gap, lacosteUA, minycenter, mns, pcardin, penti, propia, samsung, samsung\_out\_of\_stock, sc, sephora, sporjinal, superstep, superstepUA, tanca, uspa)</em></p> | `<g:product_type>` + `<c:category_hierarchy>`                                                                                                                                                                                      |
| `eh`                                                                                                                                                                                                                                                                                            | Standard pair. With `"IS_BG": true` in the `config` field, **both** tags are dropped                                                                                                                                               |
| `desa`                                                                                                                                                                                                                                                                                          | Standard pair. With `"include_category_breadcrumb": true`, adds `<category_hierarchy_2>` built from the navigation menu, which can differ from the category path                                                                   |
| `barcin`, `sportive`                                                                                                                                                                                                                                                                            | `<g:product_type>` + `<category_hierarchy>` — the ID tag loses its `c:` prefix. `sportive` additionally emits `<tkategori>` listing **every** assigned category, not only the selected one                                         |
| `vakkorama`                                                                                                                                                                                                                                                                                     | Standard pair, plus `<c:category>` duplicating the ID path                                                                                                                                                                         |
| `lacoste`                                                                                                                                                                                                                                                                                       | Standard pair, plus `<c:category_data>`. The `PRODUCT_TYPE_SPLIT_KEY` setting replaces the `>` separator inside `<g:product_type>`                                                                                                 |
| `bisse`                                                                                                                                                                                                                                                                                         | `<g:product_type>` plus `<g:google_product_category>` holding the same value. **No ID path**                                                                                                                                       |
| `base_related_mc`                                                                                                                                                                                                                                                                               | Renamed to `<category_name>` and `<category_code>`. This type **requires** every product to have a category — a single product without one stops the whole feed run, so assign a category to every product you feed with this type |
| `base_akakce`, `samsung_akakce`                                                                                                                                                                                                                                                                 | Single `<productCategory>` tag. **No ID path**                                                                                                                                                                                     |
| `base_skroutz`                                                                                                                                                                                                                                                                                  | Single `<category>` tag. **No ID path**                                                                                                                                                                                            |
| `base_persona_click`, `a101_persona_click`, `damat_persona_click`, `sc_persona_click`, `sportive_persona_click`, `spx_persona_click`                                                                                                                                                            | No category path. The selected category and its ancestors are emitted as individual `<categoryId>` elements. Set `"include_all_product_categories": true` to list every assigned category instead of only the selected one         |
| `base_cimri`, `jumbo_cimri`, `tefal_cimri`, `base_knawat`                                                                                                                                                                                                                                       | **No category information in the feed at all**                                                                                                                                                                                     |
| `kigili`                                                                                                                                                                                                                                                                                        | Emits `<g:product_type>`, but trims **two** ancestor levels instead of one. On a `Shop > Bathroom > Towel` tree it outputs `Towel` rather than `Bathroom > Towel`. On a two-level tree it matches the standard adapter types       |

{% hint style="info" %}
`INCLUDE_CATEGORY_HIERARCHY` only affects adapter types that emit an ID path. It has no effect on `base_akakce`, `samsung_akakce`, `base_skroutz`, `bisse`, the PersonaClick types, the Cimri types or `base_knawat`. Do not set it to `false` on `base_related_mc`, which builds `<category_code>` from the ID path.
{% endhint %}

#### Which Category Wins When a Product Belongs to Several Categories

Products often sit in a main category and a promotional collection at the same time — for example `Bathroom > Towel` and `Special Collection > Yacht Collection`. The feed selects the category as follows:

1. If one of the product's category assignments is marked as the **main category**, that category is used.
2. If **no** assignment is marked as main, **which category is exported is undefined.** Any one of the product's categories may be chosen, and the choice can differ between two runs with no change to the data. Do not rely on the order the assignments were created in, the category name, the category ID, or the assignment date.

{% hint style="warning" %}
Mark a main category for every product that belongs to more than one category. Without it the exported category is unpredictable.
{% endhint %}

#### Marking a Main Category

Send the category assignment with `is_main` set to `true`. The host and token follow the same convention as **Trigger Feed Generation Manually (API)** later in this guide:

```bash
curl --location --request POST 'https://{omnitron_url}/api/v1/remote/1/product_category/' \
--header 'Authorization: Token your_token_here' \
--header 'Content-Type: application/json' \
--data '{
  "product": 60671,
  "category": 3854,
  "is_main": true
}'
```

To move the flag to a different category you need the ID of each assignment, which you can list for a product:

```bash
curl --location 'https://{omnitron_url}/api/v1/remote/1/product_category/?product=60671' \
--header 'Authorization: Token your_token_here'
```

Each result carries its own `pk` and its current `is_main` value. Then send `{"is_main": false}` as a `PATCH` to the old assignment and `{"is_main": true}` to the new one:

```bash
curl --location --request PATCH 'https://{omnitron_url}/api/v1/remote/1/product_category/4821/' \
--header 'Authorization: Token your_token_here' \
--header 'Content-Type: application/json' \
--data '{"is_main": true}'
```

Flag exactly one assignment per product. Flagged assignments take priority over unflagged ones, so flagging more than one produces the same unpredictable result. The next feed run picks up the change; no adapter configuration is needed.

{% hint style="info" %}
Marking a main category requires **Akinon Commerce 1.0.0** or later. On earlier versions the exported category is undefined for a multi-category product and cannot be influenced.
{% endhint %}

#### What Category Overrides Can and Cannot Do

`CUSTOM_CATEGORY_MAPPING_ENABLED` together with `category_dict` and `category_ids_dict` — all three described under **Explanation of Key Fields** — rewrites the **text** that is exported for a category path. It does **not** change which category is selected. If a product resolves to the promotional collection, mapping that collection's path to a different label changes only the exported string — the underlying selection is still the collection.

Likewise, `filter_arguments` controls **which products** enter the feed. It cannot reorder or override category selection for a product that is already in the feed.

To export a different category, mark a main category as described above.

### <mark style="color:red;">Including Marketplace Offer Products</mark>

By default a feed exports **simple products only**. Marketplace offer products — the seller-level records created for a marketplace listing — are excluded.

Add the `product_types` key to the `config` field to change this:

```json
{
  "product_types": ["offer"]
}
```

| Value                 | Exported products                  |
| --------------------- | ---------------------------------- |
| Key not set           | Simple products only — the default |
| `["simple"]`          | Simple products only               |
| `["offer"]`           | Marketplace offer products only    |
| `["simple", "offer"]` | Both                               |

An offer product inherits its parent product's images for the purposes of the image requirement, so an offer without its own image is still exported when the parent has one. Its `<link>` points to the parent product page and carries the seller identifier as a query parameter, so the customer lands on the correct seller's listing.

{% hint style="warning" %}
`product_types` is the only key that selects offer products. `filter_arguments` cannot do it: its conditions are applied **in addition to** the product type filter, never instead of it. Putting a product type condition inside `filter_arguments` while leaving `product_types` out therefore asks for products that are simple **and** offers at the same time. Nothing matches, and the feed task aborts with `Chunk count is 0. Please check the feed generation logic.`
{% endhint %}

The correct configuration for an offer-only feed is:

```json
{
  "product_types": ["offer"],
  "filter_arguments": {}
}
```

If a feed task fails with `Chunk count is 0`, the product selection matched no products at all. Check `product_types` first, then `filter_arguments`.

{% hint style="warning" %}
An unrecognized value in `product_types` — for example `["marketplace_offer"]` — is ignored silently and the feed falls back to simple products. No error is raised. If an offer feed comes back full of simple products, check the spelling of this value first.
{% endhint %}

### <mark style="color:red;">Large Catalogs and Multipart Upload</mark>

A catalog too large for a single file is uploaded in parts and merged automatically. This was introduced in the **April 2024** Akinon release and needs no configuration.

`chunk_size` sets how many products go into each part, default `10000`.

{% hint style="warning" %}
Leave `chunk_size` at `10000`. Lowering it is the most common cause of a broken feed on a large catalog: smaller parts fall below the minimum size the storage service accepts, and the upload fails when the parts are merged.
{% endhint %}

### <mark style="color:red;">Price and Discount Configuration</mark>

By default, the feed derives its price tags from the product's price and retail (list) price:

* `g:price` → the **retail/list price** (the "struck-through" price) when the product has a discount.
* `g:sale_price` → the **actual selling price**.

When the product has no discount (no retail price, or price ≥ retail price), only `g:price` is written. You can fine-tune this behavior with the flags below—all of them are optional and belong in the same `config` JSON object.

| Field                           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CONCAT_PRICE_CURRENCY`         | Boolean, default `true`. Appends the currency code to every price value (e.g. `995.00 TRY`). Set to `false` to output the numeric value only (e.g. `995.00`).                                                                                                                                                                                                                                                                                                                                                                                        |
| `ALWAYS_INCLUDE_SALE_PRICE`     | Boolean, default `false`. When a product has no discount, still emits an empty `<g:sale_price>` tag instead of omitting it. Useful for platforms that require the tag to always be present.                                                                                                                                                                                                                                                                                                                                                          |
| `SALE_PRICE_WITH_BASKET_OFFERS` | Boolean, default `false`. **Overwrites** `g:sale_price` with the discounted price of the product's single-unit (quantity = 1) basket offer, so the sale price reflects the basket promotion. Requires the `OFFER_SHOW_LISTING_KWARGS` dynamic setting to be enabled (see hint below). Note: this replaces the real sale price—use `INCLUDE_BASKET_OFFER_PRICE` instead if you need to keep both.                                                                                                                                                     |
| `INCLUDE_BASKET_OFFER_PRICE`    | Boolean, default `false`. Emits an **additional** `<g:basket_price>` tag containing the discounted price of the product's single-unit (quantity = 1) basket offer, **without** touching `g:price` or `g:sale_price`. The tag is only written when the product actually has a matching offer. Requires the `OFFER_SHOW_LISTING_KWARGS` dynamic setting to be enabled.                                                                                                                                                                                 |
| `INCLUDE_BASKET_OFFER_LABEL`    | Boolean, default `false`. Emits an **additional** `<g:basket_offer_label>` tag containing the campaign message (the basket offer's `label`) of the **same** single-unit (quantity = 1) basket offer whose price feeds the price tags. Independent of the price flags—it can be enabled on its own. The tag is only written when the product has a matching offer and that offer has a non-empty label. Requires the `OFFER_SHOW_LISTING_KWARGS` dynamic setting to be enabled. If you need a different tag name, rename it with an attribute mapper. |
| `add_sale_price_as_price`       | Boolean, default `false`. If a sale price exists, moves it into `g:price` and drops `g:sale_price`, so the feed exposes a single (discounted) price.                                                                                                                                                                                                                                                                                                                                                                                                 |

#### Showing three separate prices (list, sale, and basket-offer price)

A common requirement is to expose the struck-through price, the sale price, **and** a separate basket-offer price at the same time. Enable `INCLUDE_BASKET_OFFER_PRICE` and leave `SALE_PRICE_WITH_BASKET_OFFERS` off:

```json
{
  "INCLUDE_BASKET_OFFER_PRICE": true
}
```

For a product with a list price of 2095.00, a sale price of 995.00, and a single-unit basket offer of 696.50, the feed then outputs:

```xml
<g:price>2095.00 TRY</g:price>
<g:sale_price>995.00 TRY</g:sale_price>
<g:basket_price>696.50 TRY</g:basket_price>
```

#### Adding the basket offer's campaign message

To also expose the campaign message of the basket offer that produced the price, enable `INCLUDE_BASKET_OFFER_LABEL`. It is independent of the price flags, so you can combine it with `INCLUDE_BASKET_OFFER_PRICE` (or use it on its own):

```json
{
  "INCLUDE_BASKET_OFFER_PRICE": true,
  "INCLUDE_BASKET_OFFER_LABEL": true
}
```

The message comes from the `label` of the same single-unit basket offer whose price is written, so the price and the message always describe the same campaign:

```xml
<g:price>2095.00 TRY</g:price>
<g:sale_price>995.00 TRY</g:sale_price>
<g:basket_price>696.50 TRY</g:basket_price>
<g:basket_offer_label>Buy one, get the second at 50% off</g:basket_offer_label>
```

The tag is omitted when the product has no matching offer or the offer's label is empty. The tag name is fixed (`g:basket_offer_label`); if the receiving platform expects a different name, map it with an attribute mapper.

{% hint style="info" %}
`SALE_PRICE_WITH_BASKET_OFFERS` and `INCLUDE_BASKET_OFFER_PRICE` are independent. Enabling `SALE_PRICE_WITH_BASKET_OFFERS` overwrites `g:sale_price` with the offer price (losing the real sale price), whereas `INCLUDE_BASKET_OFFER_PRICE` keeps `g:sale_price` intact and adds the offer price as a separate `g:basket_price` tag. There is no need to also duplicate the sale price via `duplicate_fields` when you use `INCLUDE_BASKET_OFFER_PRICE`.
{% endhint %}

{% hint style="warning" %}
Both basket-offer flags rely on the offer's listing data (`discounted_total_price`), which is only exposed when the **`OFFER_SHOW_LISTING_KWARGS`** dynamic setting is enabled for the project. If that setting is off, the basket-offer price will not appear even when the flag is set.
{% endhint %}

### <mark style="color:red;">Upload Filter Files (Optional)</mark>

To include only specific products in the feed, you can upload a filter file—**CSV** or **XLS**—containing product identifiers. Filter files help reduce feed size or tailor feeds to campaign-specific product lists. For example, if you want to export only a selection of SKUs for a seasonal collection, use a filter.

{% stepper %}
{% step %}
Go to the **Choose File** field in the adapter form.
{% endstep %}

{% step %}
Upload a `.csv` or `.xls` file.
{% endstep %}

{% step %}
File must contain a `sku` or `base_code` column.

{% hint style="warning" %}
If the file format or header is incorrect, the system will return an error:\
`No valid header found in file headers.`
{% endhint %}
{% endstep %}

{% step %}
You can also combine the uploaded filter file with additional config-based filters via the `filter_arguments` key in the config:

```json
"filter_arguments": {
  "is_listable": true
}
```

This way, only listable products **that also match the uploaded SKUs** are included in the feed.
{% endstep %}
{% endstepper %}

### <mark style="color:red;">Save and Generate the Feed</mark>

Once you’ve completed the **Basic Adapter Settings**, added your **config JSON**, and optionally uploaded a **filter file**, it’s time to save the adapter:

* Click **“Save”.**
* If your `config` field is valid and includes a `schema_data` section, the page will reload and reveal a new section called **Mapper Settings**.
* This section allows you to define the transformation logic for each XML tag listed in your `schema_data`.

{% hint style="warning" %}
If you skip the config or forget to include `schema_data`, the Mapper Settings section will **not** be displayed.
{% endhint %}

## <mark style="color:red;">Attribute Mapping with Rules and Actions</mark>

After configuring your feed schema using the `config` field, the next crucial step is to **define how each XML field (tag) retrieves its data** from the product catalog. This is done using the **Mapper Settings** section in the adapter interface.

Each XML tag listed under `schema_data` must have a corresponding **mapper**, which includes:

* A **rule** that determines when the mapping should be applied
* An **action** that defines how to fetch or transform the data

Together, these enable complex conditional logic, localization, and formatting for your feeds—ensuring data consistency and compatibility with platforms like Google Merchant Center.

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2FlrrGaVHATXWfeJPoIbam%2Fimage.png?alt=media&amp;token=560f22e3-1b06-4481-aa5a-fdcfe3e882f6" alt="" width="375"><figcaption></figcaption></figure>

Each mapper is a JSON object with two main parts:

#### 1. `rule`: *When should this mapping be applied?*

Defines the condition that must be true for the action to run.

#### 2. `action`: *How should the value be retrieved or constructed?*

Specifies how to fetch, format, or combine values.

### <mark style="color:red;">Rule Types (When)</mark>

| Rule Type              | Description                                                |
| ---------------------- | ---------------------------------------------------------- |
| `always`               | Always applies the action, regardless of product data      |
| `attributeexists`      | Applies only if a specific attribute exists on the product |
| `multiattributeexists` | Checks if multiple attributes exist (can be all or any)    |
| `query`                | Applies if a certain query condition is met (advanced)     |
| `in_dict`              | Checks if a field exists in a predefined dictionary        |

### <mark style="color:red;">Action Types (How)</mark>

| Action Type          | Description                                               |
| -------------------- | --------------------------------------------------------- |
| `attrgetter`         | Retrieves a single attribute value                        |
| `attrformatter`      | Formats an attribute using a custom template              |
| `multiattrformatter` | Combines multiple attributes into a single string         |
| `outputdict`         | Uses a dictionary to map internal values to output values |
| `stdout`             | Outputs a static value (useful for fixed tags)            |

#### Basic Example: Simple Attribute Getter

This mapper fetches the `description` field from the product data and maps it directly to the `<description>` XML tag.

```json
{
  "rule": {
    "rule_type": "always"
  },
  "action": {
    "action_type": "attrgetter",
    "action_kwargs": {
      "input_key": "description"
    }
  }
}
```

#### Example: Formatting Gender Using Output Dictionary

If your internal values for gender are stored as `M`, `F`, and `U`, but Google requires `male`, `female`, and `unisex`, use this:

```json
{
  "rule": {
    "rule_type": "always"
  },
  "action": {
    "action_type": "outputdict",
    "action_kwargs": {
      "input_key": "gender",
      "mapping_dict": {
        "M": "male",
        "F": "female",
        "U": "unisex"
      }
    }
  }
}
```

#### Combine Multiple Attributes

Use this action when you need to generate a value from multiple fields (e.g., combining brand + title + size).

```json
{
  "rule": {
    "rule_type": "always"
  },
  "action": {
    "action_type": "multiattrformatter",
    "action_kwargs": {
      "input_keys": ["brand", "title", "size"],
      "format_str": "{0} - {1} ({2})",
      "delimiter": " "
    }
  }
}
```

**Output Example:** `Nike - Air Max (42)`

### <mark style="color:red;">Handling Localized Fields</mark>

When generating feeds in **multiple languages**, you need to retrieve the correct **language-specific values** from product data. The format of your `input_key` inside the **mapper's `action_kwargs`** will vary depending on:

* Whether the feed is for the **default language**
* Whether the field is a **text** or **dropdown** attribute

#### <mark style="color:red;">For Default Language Feeds</mark>

If you're generating a feed in your **default language**, product attribute values can be accessed using this structure:

```json
"input_key": "attributes__{{attr_code}}"
```

This directly pulls the attribute from the product's default data.

#### <mark style="color:red;">For Localized Feeds (Non-Default Languages)</mark>

For other languages (e.g., Arabic, Turkish, English (US)), you need to reference **localized fields**. The structure depends on the **type of attribute**.

#### For text fields:

Use `localized_attributes` for retrieving translated text fields such as `title`, `description`, or `long_name`.

***Pattern:***

```
localized_attributes__{{language_code}}__{{attribute_code}}
```

***Example:***

```json
[
  {
    "rule": {
      "rule_type": "always",
      "rule_kwargs": {}
    },
    "action": {
      "action_type": "attrgetter",
      "action_kwargs": {
        "input_key": "localized_attributes__en-us__l_name"
      }
    },
    "shared_kwargs": {}
  }
]
```

#### For dropdown fields:

For dropdown attributes that have translated options (e.g., brand, material, gender), use the `attributes_kwargs` structure to access the translated label.

***Pattern:***

```
attributes_kwargs__{{attribute_code}}___translations__{{language_code}}__label
```

***Example:***

```json
[
  {
    "rule": {
      "rule_type": "always",
      "rule_kwargs": {}
    },
    "action": {
      "action_type": "attrgetter",
      "action_kwargs": {
        "input_key": "attributes_kwargs__brand___translations__ar__label"
      }
    },
    "shared_kwargs": {}
  }
]
```

{% hint style="warning" %}
Use the appropriate `language_code` (e.g., `en`, `ar`, `tr`) depending on the feed’s target market.
{% endhint %}

## <mark style="color:red;">Triggering and Monitoring Feed Generation</mark>

Once your Merchant Feed Adapter is configured and saved, it's time to **generate the actual XML feed file**. Omnitron provides both **automated** and **manual** triggering methods for this purpose. You can also **track the status** of the generation process and retrieve the final file URL programmatically.

**Automatic vs. Manual Triggering:**

| Trigger Type              | Description                                                                                                                                                       |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Automatic (Scheduled)** | If the adapter's `One Time` checkbox is **unchecked**, Omnitron will automatically run the feed generation task every 3 hours.                                    |
| **Manual (One-Time)**     | If `One Time` is checked, the feed must be triggered manually via the API or Omnitron UI. This is useful for test feeds, campaign-based feeds, or ad-hoc exports. |

### <mark style="color:red;">Trigger Feed Generation Manually (API)</mark>

To manually trigger feed generation for a specific adapter:

#### **Endpoint:**

```bash
POST /api/v1/remote/1/product_merchant_feeds/{adapter_pk}/trigger_task/
```

Replace `{adapter_pk}` with the ID of the adapter you want to trigger.

#### Example Request:

```bash
curl --location --request POST 'https://{omnitron_url}/api/v1/remote/1/product_merchant_feeds/268/trigger_task/' \
--header 'Authorization: Token your_token_here'
```

#### Example Response

```json
{
  "cache_key": "6c27bc5a8f06442f96044302e6168d7a"
}
```

### <mark style="color:red;">Monitor Progress of Feed Generation</mark>

You can track the progress of the feed task using the returned `cache_key`.

#### Endpoint:

```bash
GET /api/v1/remote/1/product_merchant_feeds/{adapter_pk}/trigger_status/?cache_key={cache_key}
```

#### Example Request:

```bash
curl --location 'https://{omnitron_url}/api/v1/remote/1/product_merchant_feeds/268/trigger_status/?cache_key=6c27bc5a8f06442f96044302e6168d7a' \
--header 'Authorization: Token your_token_here'
```

#### Example Response:

```json
{
  "completed_tasks": 1,
  "data": [
    {
      "progress": [1, 1],
      "completed": true,
      "chunk_count": 1
    }
  ],
  "progress_count": 1
}
```

{% hint style="warning" %}
**`progress: [x, y]`** represents **x completed chunks out of y total**. You can calculate progress percentage as:\
`(x / y) * 100`
{% endhint %}

### <mark style="color:red;">Get Feed File URL</mark>

Once the task is completed, the file will be available at the adapter’s detail endpoint.

#### Endpoint:

```bash
GET /api/v1/remote/1/product_merchant_feeds/{adapter_pk}/
```

#### Example Request:

```bash
curl --location 'https://{omnitron_url}/api/v1/remote/1/product_merchant_feeds/268/' \
--header 'Authorization: Token your_token_here'
```

#### Example Response:

```json
{
  ...
  "file_url": "https://cdn.akinoncloud.com/google/insider-feed_en.xml"
}
```

You can now use this file URL in your Google Merchant Center, comparison shopping platforms, or campaign tracking tools.

### <mark style="color:red;">Error Handling</mark>

If a feed task is already in progress and a new one is triggered:

#### Example Response:

```json
{
  "non_field_errors": "Google Merchant Feed task is already running. Please wait until the current task is completed before starting a new one.",
  "error_code": "google_merchant_feed_adapter_100_2"
}
```

{% hint style="warning" %}
Always check if a task is running before triggering a new one to avoid queue conflicts.
{% endhint %}

### <mark style="color:red;">Triggering Feed Manually via Omnitron</mark>

In addition to using API calls, you can also **manually trigger feed generation directly from the Omnitron interface**—with just a few clicks.

{% stepper %}
{% step %}
**Select the Feed Adapter(s):**

Use the checkbox on the left to select the adapter(s) you want to run. You can select one or multiple rows.
{% endstep %}

{% step %}
**Open the "Select Action" Dropdown:**

At the top of the list, open the **Select Action** dropdown.
{% endstep %}

{% step %}
**Click “Trigger Task with Selected Items”:**

This option will immediately initiate the feed generation task for the selected adapters.

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2FjBDwY7pTokaDn0IgYdjT%2Fimage.png?alt=media&amp;token=b49aaf23-9595-49f1-bad0-d9da784f5c86" alt=""><figcaption></figcaption></figure>
{% endstep %}

{% step %}
**Click “Apply”:**

The task will be queued and executed via Celery. You can monitor the task’s status using the API or check the file URL once generation is complete.

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2FpsEKIhyRFKIG9JPyOcpt%2Fimage.png?alt=media&amp;token=7ba1ce75-0550-465c-a573-a05bb1d09ace" alt=""><figcaption></figcaption></figure>
{% endstep %}
{% endstepper %}

## <mark style="color:red;">Feed URL Usage</mark>

Once the feed generation is complete, the XML file becomes accessible via the provided `file_url`.\
For example, you can access the generated feed directly at:

{% embed url="<https://2c1676.s3.amazonaws.com/insider/insider-feed_en.xml>" %}

<figure><img src="https://3333414532-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIbwGN7KwvYi0iLbjtnXz%2Fuploads%2FOifLMaVFUXG1CIiLDR1Z%2Fimage.png?alt=media&amp;token=0652ed13-3ec4-4df0-81dc-87f5b1fc082e" alt=""><figcaption></figcaption></figure>

You can now use this URL to upload the feed to Google Merchant Center or share it with external platforms that support scheduled product feed imports.

{% hint style="warning" %}
This URL remains valid as long as the feed is not deleted or regenerated under a different filename.
{% endhint %}

## <mark style="color:red;">Troubleshooting Missing or Incorrect Fields</mark>

When the feed does not contain what you expect, first identify which of the three cases below applies; the checks are different for each. If **every** product is missing, start with the filter file and the `price_list_id` / `stock_list_id` rows.

### <mark style="color:red;">A Product Is Missing From the Feed</mark>

The feed applies several filters, and a product that fails any one of them is dropped silently — no error appears in the feed or in the task result. The `config` keys named below are described under **Explanation of Key Fields**, and filter files under **Upload Filter Files (Optional)**. Check these in order:

| Check               | What to look for                                                                                                                                                                                                       |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Product status      | The product must be active.                                                                                                                                                                                            |
| Hidden flag         | A product whose `attributes.is_hidden` value is `true` is excluded.                                                                                                                                                    |
| Product type        | The product's type must be listed in `product_types`. Feeds export simple products only unless you add `"offer"`.                                                                                                      |
| Image               | The product must have at least one image. Offer products may inherit the parent's image.                                                                                                                               |
| Price               | The product must have a price. When `price_list_id` is set, the product must have a price **in that price list** — a base price is not enough.                                                                         |
| Stock               | Zero-stock products are excluded unless `"include_stock_out_products": true` is set. When `stock_list_id` is set, the product must have a stock record in that stock list.                                             |
| Filter file         | If a filter file is uploaded, only the products listed in it are exported. The file must have a `sku` or `base_code` column header; a wrong header is rejected with *No valid header found in file headers.*           |
| `filter_arguments`  | A product that does not match **every** condition listed here is excluded. Conditions are applied in addition to the `product_types` filter, not instead of it.                                                        |
| `exclude_arguments` | Products matching these conditions are removed. Multiple conditions are combined with `exclude_operator`, which defaults to `"or"`; set it to `"and"` to require every condition to match before a product is removed. |

{% hint style="info" %}
If **every** product is filtered out, the task does not produce an empty feed — it fails with `Chunk count is 0. Please check the feed generation logic.` Seeing that message means one of the filters above is too strict. Check the list-scoped filters first: a `price_list_id` or `stock_list_id` pointing at a list with no records for this catalog removes every product, as does a filter file whose identifiers match nothing.
{% endhint %}

### <mark style="color:red;">A Product Is Present but a Tag Is Missing or Wrong</mark>

The attribute mappings referred to below are configured as described in **Attribute Mapping with Rules and Actions**.

| Symptom                                                      | Cause and fix                                                                                                                                                                                                                |
| ------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The tag is absent entirely                                   | A `schema_data` entry produces no tag at all — not an empty one — when it has neither a matching attribute mapping nor a `default_value`. Add a `default_value` to guarantee the tag is always written.                      |
| The tag holds the default value instead of the product value | The attribute mapping did not resolve. Confirm a mapper exists for exactly this tag name as it appears in `schema_data`, and that it is attached to **this** feed adapter — a mapper created for another adapter is ignored. |
| The tag holds a product value instead of the default         | An attribute mapping takes precedence over `default_value`. Remove or adjust the mapping.                                                                                                                                    |
| A mapping silently does nothing                              | A malformed rule or action in a mapping is skipped so that it cannot break the whole feed. Re-check the rule type, action type, and their parameters.                                                                        |
| `<g:gtin>` is missing                                        | `"IS_REQUIRED_GTIN": false` writes the SKU into `<g:mpn>` instead.                                                                                                                                                           |
| `<g:product_type>` is missing                                | The product has no category assignment.                                                                                                                                                                                      |
| `<g:product_type>` shows the wrong category                  | The product belongs to several categories and none is marked as main. See **Category Selection for `g:product_type`**.                                                                                                       |
| `<c:category_hierarchy>` is missing                          | `"INCLUDE_CATEGORY_HIERARCHY": false` is set.                                                                                                                                                                                |
| `<g:availability>` reads `out of stock`                      | Expected when `"include_stock_out_products": true` is set and the product has no stock.                                                                                                                                      |

### <mark style="color:red;">The Feed Did Not Regenerate at All</mark>

The **Status** and **One time** fields are set on the adapter form, described under **Fill in Basic Adapter Settings**. Manual triggering is covered in **Triggering and Monitoring Feed Generation**.

| Check                                    | What to look for                                                                                                                                                                   |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Adapter status                           | A `Passive` adapter is skipped by scheduled runs.                                                                                                                                  |
| **One time** checkbox                    | A one-time adapter never runs on the schedule. Trigger it manually.                                                                                                                |
| Task already running                     | Triggering while a task is in progress is rejected with HTTP 406 and error code `google_merchant_feed_adapter_100_2`. Wait for the running task to finish.                         |
| Run fails with `Chunk count is too high` | The catalog needs more than 1000 parts. Raise `chunk_size` until the part count drops to 1000 or below.                                                                            |
| Run fails with `EntityTooSmall`          | `chunk_size` is too low, so the upload parts are below the minimum size the storage service accepts. Set it back to `10000`.                                                       |
| Upload failed                            | A failed upload leaves the previous file in place, so the feed URL keeps serving stale content. Runs are retried automatically; if the feed stays stale, check the two rows above. |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.akinon.com/tutorials/omnitron/sales-channels/content-management/how-to-configure-merchant-feed-adapter.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
