Mergado

Create a 'Bidding' rule in a project. Adjust a CPC element's value based on product price. Specify an absolute increment, a percentage factor, or both. At least one field must be non-null. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants CPC bidding values set. Free with every project. The word CPC does not imply the paid Bidding Fox; that one is needed only when the bid must react to live auction positions.

create_bidding_rule

Create a 'Calculation' rule in a project: evaluates a mathematical expression and writes the result into `element_path`, optionally rounded and formatted. Supports + - * / and parentheses with standard operator precedence (* and / bind before + and -), so a flat expression like `1-%COST%/%PRICE%*100` evaluates as `1-((%COST%/%PRICE%)*100)` — parenthesise anything beyond a single operation. `%element%` references resolve to the product's current value at runtime; a value written with a space thousands separator and a decimal comma ("1 234,56") parses correctly. Use when the user wants a computed numeric value — margins, VAT, price adjustments, currency conversion. Rounding and number formatting are built into this rule (`rounding_type`, `decimal_places`, `decimal_separator`, `thousand_separator`), so no second rule is needed for that; use `create_rounding_rule` only to reformat an existing value with no arithmetic. A product whose expression cannot be evaluated — a non-numeric operand, or division by zero — is skipped and keeps its previous value; the rule itself does not fail. With `rounding_type` unset the raw result is written (e.g. `371.9008264463`), which most feed formats reject. The call returns the created rule only; computed values appear in the output after the next rebuild. Free with every project. The only pricing job it cannot do is reacting to competitor prices — that needs the paid Pricing Fox.

create_calc_rule

Create a 'Case Changing' rule in a project. Transform the capitalisation of text in an element. Supported modes: `lower`, `upper`, `sentence`, `word`, `firstletter`, `titlelongwords`. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants to change the letter case of a value.

create_casechanging_rule

Create a 'Categories' rule in a project. Rename product categories by partial (or exact) match. Each row maps an input pattern to an output replacement. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants to bulk-rename categories into the format's category element (it ignores a custom `element_path`).

create_categories_rule

Create an 'Add a Value to a Multi-Value Element' rule in a project. Appends a NEW value to an element that can hold multiple values (e.g. `g:additional_image_link`, categories, PARAM, alternative URLs) WITHOUT overwriting existing values — it writes to the next free position (equivalent to a Rewriting rule with element path `ELEMENT {@@POSITION = @@MAX_POSITION + 1}`). Use when the user wants to append an additional value to a multi-value element (e.g. add a second image or an extra category) without replacing what is already there. On an empty element it creates the first value; on an element that already has values it adds one more. Mergado variable expressions (e.g. `%element%`) are supported. Provide this rule type's parameters in the typed `data` object. At least one query is required in `queries` (objects `[{"id": "..."}]`); use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs.

create_create_product_value_rule

Create a 'Hiding' rule in a project. Hide (remove from output) all products that match the rule's queries. No additional data fields are required. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants to remove whole products from the output feed.

create_hiding_rule

Create a 'Params Remove By Value' rule in a project. Hide specific parameter values (or entire parameters) from the output. Each row specifies a parameter name and the list of values to remove. An empty `values` list removes all values for that parameter. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants specific parameter values removed from a PARAM-style structure.

create_params_remove_by_value_rule

Create a 'Product Grouping' rule in a project. Group variant products together into a single product with multiple variants. Specify which elements identify products and groups, and define per-element MERGE or EXTRACT actions. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). This rule type does not require any queries. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants product variants merged (a whole-feed rule).

create_product_grouping_rule

Creates a new product tag in the project. Returns the current list of tags.

app_biddingfox_create_product_tag

Creates a standalone, reusable query in a project (a saved MQL product selection) that can be attached to one or more rules with `assign_query_to_rule`. Even a query used by a single rule is created here first, then attached via `assign_query_to_rule`. Use to define which products a rule should target, or to verify a hypothesis about the data (check the match via `list_project_products` with the same `mql`). The query is re-evaluated on every project rebuild — write it as a condition over element values, not as a list of product IDs matching the condition today. Call workflow_element_paths_and_mql first for MQL limits and selection patterns.

create_project_query

Create a 'Remove Diacritics' rule in a project. Remove diacritical marks (accents) from the content of the targeted element. Useful for generating URL-safe or ASCII-only values (e.g. image URLs). No additional configuration is required. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants accents/diacritics removed from a value.

create_remove_diacritics_rule

Create a 'Replacing' rule in a project. Find and replace content within element values. Supports plain text and regular expressions. Multiple search/replacement pairs can be specified in `rows`. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants find-and-replace inside values (plain text or regex with `\1` group references). Free with every project. Covers swapping a domain inside IMGURL — that changes which picture the feed carries, not the picture itself, so no Feed Image Editor is involved.

create_replacing_rule

Create a 'Rewriting' rule in a project. Replace the content of one or more product elements with a new value. Mergado variable expressions (e.g. `%ITEM_ID%`) are supported in `new_content`. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants to overwrite an element's content (supports `%element%` references). Free with every project. Covers pointing IMGURL at a different URL — that changes which picture the feed carries, not the picture itself, so no Feed Image Editor is involved.

create_rewriting_rule

Create a 'Rounding' rule in a project. Round a numeric element value to a fixed number of decimal places. The separators control how the formatted output looks. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants prices rounded. Free with every project. Use it for reformatting alone — when the value is being computed, round inside create_calc_rule instead of adding a second rule.

create_rounding_rule

Creates a new pricing rule in the project. PAID, per project. Only when the price must react to COMPETITOR prices from Heureka/Zbozi.cz; plain arithmetic is the free create_calc_rule. Pricing rules are first-match-wins.

app_pricingfox_create_rule

Create a 'Tag Stripping' rule in a project. Remove all HTML tags from the content of the targeted element. No additional configuration is required. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants HTML tags stripped from a value.

create_tagstripping_rule

Create a 'Truncating' rule in a project. Shorten the content of an element to a specified maximum length. The intelligent flag attempts to truncate at a word boundary. The *append* string (e.g. `...`) is appended after the truncated text. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants values shortened to a length limit.

create_truncating_rule

Create a 'UTM Parameters' rule in a project. Append UTM tracking parameters to product URLs. Mergado variable expressions (e.g. `%ITEM_ID%`) are supported in all text fields. Provide this rule type's parameters in the typed `data` object (its fields are fixed by the schema). At least one query is required in `queries` (objects `[{"id": "..."}]`) use the ♥ALLPRODUCTS♥ query to target every product. Mergado applies the rule automatically on the next rebuild — do not force recalculation. After creating, read the rule back with `get_rule` and verify its effect on a sample once the rebuild runs. Use when the user wants UTM tracking parameters appended to product URLs.

create_utm_rule

Creates a variable in a project. Use for: (a) named constants used by multiple rules (shipping_cost, vat_rate), (b) regex extraction (define a regex once, reference it in rules), or (c) computed values. The variable name becomes the reference token in rules: `{name}`.

create_variable

Creates a new element in a project. Use when adding an output element required by a target format (e.g. `g:gtin` for Google Shopping) that does not yet exist in the element tree. After creating it, use a rule (e.g. a `create_<type>_rule` tool) to fill it with values. Pass `parent_id` to nest it under an existing element (a child), or omit it for a top-level element.

create_element

Add a new layer to a template's canvas. Returns all template layers in their new stacking order. Right before calling, re-read templates_layers_list and templates_get_size: another client (web editor, agent) may edit the template in parallel. Required fields by type: - text, textWithElements: text_content, text_fontsize; dynamicText (feed value as text): text_xml_element, text_fontsize; rating: rating_xml_element, text_fontsize; - other text layers with a text_content: text_fontsize and text_fontfamily too; - imageFromElements (image from a feed URL): image_xml_element; customSet (uploaded image): custom_set_id and custom_set_file_id from custom_images_upload; - line, polygon, bezier, curvedText, textInsideShape: points (see templates_layers_points_guide). Every *_xml_element must exist in the project — never guess it. Colors (text, fill, stroke, gradients): unless the user specifies them, use the project's brand colors from custom_palettes_list (prefer the selected palette) and keep text readable against its background. Basic shapes (circle, ellipse, rectangle, square, rounded rectangle, corner/right triangle) MUST use the built-in shape types circle, ellipse, rectangle (square = equal width/height, rounded: corner_radius), triangle1 (right angle bottom right), triangle2 (right angle bottom left), even with no text inside (just omit text_content; fill = color, rotate/mirror with angle, is_flip, is_flop). Use polygon / bezier / textInsideShape only for outlines these types cannot draw (e.g. isosceles triangle, star, hexagon, arrow). Geometry (all types except dashedFrame): x/y/width/height are required, x/y is the layer CENTER. Unless asked otherwise the whole layer must fit the canvas: first scale width/height down to <= canvas width/height (keep the aspect ratio for images; moving x/y alone is not enough), then pick width / 2 <= x <= canvas width - width / 2 and height / 2 <= y <= canvas height - height / 2. dashedFrame (dashed border) always spans the whole canvas: width = line THICKNESS in px (e.g. 10), not the frame width; send x, y, height = 0; style it with color, dash_length, dash_density (gap) and margin_x / margin_y (inset). Stacking: a lower priority is rendered on top. Dynamic (feed-bound) layers — textWithElements, dynamicText, imageFromElements, rating — always stay above static ones (enforced). Omit priority to put the new layer on top of its group; move it later with templates_layers_reorder. sourceImage (also called product layer / product image / source image) is the static product image layer, at most one per template, usually the bottom layer (treat it as the bottom when not listed); other static layers such as a background may sit below it. Point-based layers (line, polygon, bezier, curvedText, textInsideShape): points are relative to the layer CENTER (positive y goes DOWN) and width/height must cover them; read templates_layers_points_guide first for the point format, sizing and examples. Clip mask (optional, all types except dashedFrame, incl. sourceImage): clip_mask = filled mask objects over the layer box; only the covered parts stay visible (union of all objects), invert_clip_mask = true cuts the covered parts out instead. The mask never draws anything. Unlike points, mask x/y is the object CENTER relative to the layer TOP-LEFT corner (x = width / 2, y = height / 2 is the middle); angle rotates clockwise. - rect: width, height (left half of a 400x300 layer: [{type:"rect",x:100,y:150,width:200,height:300}]); ellipse: width, height; circle: width = diameter (round photo in a 400x400 layer: [{type:"circle",x:200,y:200,width:400}]); - polygon: >= 3 points relative to the object center, closes itself (triangle in a 400x400 layer: [{type:"polygon",x:200,y:200,points:[{x:0,y:-200},{x:200,y:200},{x:-200,y:200}]}]); - bezier: >= 2 points {x, y, cx, cy} relative to the object center, smooth segments, cx/cy belongs to the end point, closes itself; polygon/bezier may have strokeWidth to widen the outline; - text: textContent, fontFamily (text_fontfamily values), fontSize — the layer shows through the letters (inverted: letters cut out). Prefer corner_radius over a clip mask for simple rounded rectangles. (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_layers_create`.) PAID, per project. EDITS the photos already in the feed — watermark and background removal, upscale, outpainting, autocrop, price tags, logos — published at new URLs. Needed for any change to the picture itself; changing which URL the feed carries is a free core rule.

app_feedimageeditor_templates_layers_create

Create a new template in a project: name, output size (width/height, or omit to use a project default), background color, an optional AI effect (Upscale, Outpainting, or Background removal), and the product selection (queries) it applies to. **`queries` is required and must contain Mergado query ids that exist in this project — they are not FIE ids and cannot be guessed.** Before calling, get them from the Mergado MCP `list_project_queries` (same `project_id`) and pick the query matching the products the user wants; for all products use the project's all-products query (in Mergado usually named `♥ALLPRODUCTS♥`). If no query fits, ask the user which product selection to use rather than inventing an id. As for size, you may create a new size, or use existing with size_id from `sizes_list`, or you may also keep size of the images as it is (for this case there cannot be more layers, only the product source image). When asking for the size by its width and height (non-numeric size_id) from `sizes_list` of the specific channel (alza, facebook, google, ...) prefer the size with matching channel, but be sure the width and height is exactly what asked. Unless the user specifies the background color, use the project's brand colors from `custom_palettes_list` (prefer the selected palette). (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_create`.) PAID, per project. EDITS the photos already in the feed — watermark and background removal, upscale, outpainting, autocrop, price tags, logos — published at new URLs. Needed for any change to the picture itself; changing which URL the feed carries is a free core rule.

app_feedimageeditor_templates_create

Returns the link to the Mergado page where the user deletes a project, together with the project's name so they can confirm it is the right one. Use when the user asks to delete, remove or get rid of a project. This tool deletes NOTHING and cannot: Mergado has no delete endpoint (`DELETE /projects/{id}/` answers 405), because removing a project takes a feed offline for every advertising channel reading it, and that decision is left to a human in front of the confirmation dialog. All this does is read the project - to check it exists and to name it - and build the address of that dialog. So do not report the project as deleted. Give the user the link, tell them it is the last step and that they still have to confirm it there, and say which project it is for. Deleting a project cannot be undone, and its rules, queries and history go with it.

delete_project

Deletes a query. If the query is attached to a rule, that rule is left with one fewer scope query - or fails on the next apply if it was the only one (every rule must have at least one query). Check `list_rule_queries` for consumers first. System queries (`read_only=true`) cannot be deleted. Use to clean up queries you created; ask the user before deleting queries you did not create.

delete_query

Deletes a rule permanently. The products it affected revert to their pre-rule values on the next rebuild; the queries it used stay in the project. Get the user's explicit confirmation first, especially for high-priority rules (applied first) or `format_converter` rules (essential for output). Rules with `is_deletable: false` cannot be deleted. Not meant for switching a rule off temporarily - a paused rule (`update_rule`, `applies: false`) keeps its configuration, position and queries.

delete_rule

Deletes a variable. Rules referencing this variable will silently fail to expand the `{var_name}` token on the next rebuild - search rules for references first (`list_project_rules`). Use to clean up variables you created; ask the user before deleting others.

delete_variable

Deletes an element AND all of its child elements. Any rules referencing this element will break. Get the user's explicit confirmation, especially for parent elements (e.g. PARAM, g:shipping). Check the `children` field from `list_project_elements` and list the affected children in the confirmation. Use only to remove an element you created (e.g. a helper element after a one-off import); ask the user before deleting anything else.

delete_element

Permanently delete one layer from a template. Get the layer_id from `templates_layers_list` first — only layers of the given template can be deleted. This cannot be undone: confirm with the user before calling, naming the layer (its type and text/content), not just its id. To delete several layers, call this tool once per layer. Returns `deleted_layer` (the layer's state right before deletion, enough to recreate it with `templates_layers_create` if needed) and `layers` (the template's remaining layers in stacking order); the priorities of the remaining layers are not renumbered. The template can be edited in parallel by another client (the web editor or another agent): right before calling, re-read the layers with `templates_layers_list` and check the layer still exists and is the one the user confirmed — layer ids and contents may have changed since you last looked. (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_layers_delete`.)

app_feedimageeditor_templates_layers_delete

Permanently delete a template from a project. This cannot be un-done. Confirm with the user before calling; consider `templates_copy_from_project_to_project` first if the template might still be needed elsewhere. (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_delete`.)

app_feedimageeditor_templates_delete

Copies an existing project into the same shop, or into another shop when `shop_id` is given. Use when the user wants a second feed built on the same rules - the same products exported to another channel, or a copy to experiment on without touching the original. Copied: the project settings and project info, its elements, variables, queries, and its whole rule chain with schedules. NOT copied: app rules, Heureka Watchdog pairing rules, and everything produced by a feed run (products, logs, the export URL). The copy is created immediately and answers with its `id`, but it holds no data yet: Mergado enables it and schedules its first feed download straight away, and the products appear when that import and the first rule apply have finished. So do not read products from it, or judge its rules by them, right after creating it. Its feed URL does not work yet either - and the copy reports the SOURCE project's `exported_items` until it has exported once, so that number is no evidence to the contrary. Two things this changes and cannot undo, so get the user's explicit consent first: it creates a live project that starts downloading the source feed, and (with `shop_id`) it can put it in a different shop. The name must be unique in the target shop, and the token must belong to a user - Mergado records who duplicated the project, so a service token is refused.

duplicate_project

Create a copy of an existing template in the same project, including its size, layers, AI settings, and product selection. The copy is appended after the original in priority order. **The response currently echoes the source template's id, not the new copy's** — always confirm the new template's actual id with `templates_list` afterward before referencing it in another call. Use before experimental changes you may want to revert, or to build an A/B variant. (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_duplicate`.)

app_feedimageeditor_templates_duplicate

Edits an existing pricing rule in the project. All required fields must always be sent (not just the changed ones) – load the current rule via list_rules first and resend the unchanged values as they are. PAID, per project. Only when the price must react to COMPETITOR prices from Heureka/Zbozi.cz; plain arithmetic is the free create_calc_rule. Pricing rules are first-match-wins.

app_pricingfox_edit_rule

Returns the unique values (with counts) of an element. Set `is_output` to distinguish input (pre-rules) vs output (post-rules) values. Works for both simple and complex element paths. Use as the first step of any data analysis — real values of an element across products (e.g. categories, availability values) without reading whole products.

list_unique_element_values

Call this before constructing element paths, product queries (MQL), or regular expressions. Provides syntax rules and reference guides for nested element paths (using | and conditions { }), MQL query operators and filtering logic (MQL is not SQL), input vs. output element mapping, PCRE regex capture groups, and best practices for diacritics and element value matching.

workflow_element_paths_and_mql

Enable or disable visual similarity matching for a template: finds products with visually similar images elsewhere in the feed and links them to each product. `visual_similarity_threshold` sets the minimum similarity score (0-1), `visual_similarity_n` how many similar products to attach (default 5), `visual_similarity_templateids` restricts the search to images produced by specific templates. (Tool names above are bare; in Mergado's MCP prepend `app_feedimageeditor_`, e.g. `app_feedimageeditor_templates_visual_similarity`.)

app_feedimageeditor_templates_visual_similarity

Call this when troubleshooting feed errors, data discrepancies, or advertising channel rejections (e.g. Google Merchant Center, Meta, Heureka). Provides step-by-step diagnostic workflows for common feed issues including zero product imports, unmatched data imports, missing attributes (GTIN, images, shipping), stale data, and interpreting Product Data Audit findings.

workflow_feed_diagnostics

Returns details of a single access record. Returns 410 if the related project has been deleted (the log is preserved but the linked resource is gone). Use rarely - the `get_access_logs` listing is usually enough.

get_access_log

Returns the history of HTTP access to the project's output feed URL - which ad-channel crawlers (GMC, Heureka, ...) fetched the feed, when, and the response status. Use to verify ad channels are consuming the feed regularly.

get_access_logs

Returns metadata of a specific app from the global catalog by its slug name (e.g. 'biddingfoxelements', 'feedimageeditor', 'mergadoaudit'). Use to look up an app's description, latest release date, or capabilities. For apps currently enabled by a user/shop/project, use `list_user_apps` / `list_shop_apps` / `list_project_apps`.

get_app_by_name

Returns details of a single rule-application run. Use after `get_apply_logs` when you need granular per-rule diagnostics for a specific run.

get_apply_log