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

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. type decides which other fields are required: plain text (text) needs text_content; feed-bound text (textWithElements/dynamicText) and rating (rating) need the matching *_xml_element field(s) — must be an element that actually exists in the project; a previously uploaded image (customSet) needs the custom_set_id/custom_set_file_id returned by custom_images_upload; a feed-bound image (imageFromElements) needs image_xml_element. x/y/width/height (all required) position and size it on the canvas. A feed-bound (is_dynamic) layer must end up stacked above static layers — see templates_layers_reorder. 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. 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 and all of its rule-level queries (project-level queries persist). Products previously affected by this rule revert to their pre-rule values on the next rebuild. 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. Use to remove a rule after user confirmation. To change an existing rule's name or configuration prefer `update_rule` (keeps position and queries); delete + recreate only when changing the rule's type.

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, identified by layer_id (get it from templates_layers_list). This cannot be undone — confirm with the user before calling. Returns the deleted layer's last known state.

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.

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.

app_feedimageeditor_templates_duplicate

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 AI-based feed enrichment for a template: automatically generates product attributes (e.g. color, material, pattern, style) from each matching product's image and writes them into the feed as new elements.

app_feedimageeditor_templates_ai_params

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.

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

Returns the history of rule-application runs for a project (timestamp, duration, item count, per-rule processed counts). 'Apply' transforms data internally, it does not publish to the output feed - that is 'rebuild'. Use for forensic "when were rules last applied" or to diagnose unexpected rule behavior.

get_apply_logs