Elbuz connects to your ManoMano store with a Toolbox API key: it pulls in offers and orders and returns prices, stock and shipments.
When you need this:
- You sell in several ManoMano countries — one template per contract.
- Orders must be accepted on time — Elbuz accepts them on every import.
- Prices and stock are calculated in Elbuz — the export updates them and lists offers on existing pages by barcode.
- You ship from your own warehouse — your order status sends a tracking number, refusal or refund.
Where to start: create an API key in Toolbox and paste it with the Seller contract ID into a “ManoMano” import template.
What the ManoMano connection does
- Connection with an API key — no app link, one template per contract.
- Offer import — SKU, price, stock and whether the offer is on sale.
- Orders with auto-acceptance — new orders are accepted on the marketplace during the import.
- Prices and stock back to the marketplace — in batches, with the result in the log.
- New offers by barcode — on product pages that already exist on ManoMano.
- Shipping, refusals, refunds — triggered by your order status.
What to get from Toolbox
The API key is created by a Toolbox user with the Admin role: Settings → API keys → Create API key. Toolbox shows the key only once — copy it into the template right away. The contract number (Seller contract ID) is also in Toolbox: one contract means one country and one delivery method.
1
API key2
Seller contract ID3
EAN search locale4
Carrier grid for new offers- API key — from Toolbox: Settings → API keys, shown only once.
- Seller contract ID — the contract number: country and delivery method.
- EAN search locale — which country’s catalog is checked for new offers.
- Carrier grid for new offers — the grid name from Toolbox and the delivery time in days.
| Template field | What to enter |
|---|---|
| API key (Toolbox → Settings → API keys) | The key from Toolbox. Required |
| Seller contract ID | The contract number. Required |
| EAN search locale | fr_FR, es_ES, it_IT, de_DE or en_GB — which country's catalog to check before a new offer. Empty — fr_FR |
| Carrier grid for new offers | The carrier grid name from Toolbox and the delivery time in days: name|min|max. Empty — CARRIER_GRID_1|2|5 |
The search locale and carrier grid are used only when exporting new offers. The key and contract number are enough for the catalog and orders.
Once you've pasted the key and number, wait for “All changes saved” and click “Test connection”. Elbuz requests one order of the contract from the marketplace and replies “Connection works. ManoMano — seller contract #‹number›”. A wrong key gives “Connection failed: HTTP 401: …”.
“Active” and “Orders” are already on in a new template: 5 minutes after you save the key, Elbuz starts fetching and accepting orders from the last 30 days. Elbuz maps marketplace statuses to yours automatically, by name; the template's “Order statuses” window shows what came in and how it was mapped. Want to check first? Clear “Orders”.
The methods Elbuz uses are described here: ManoMano Partners API.
What goes into the product card
Elbuz pulls in your offers for the contract — both on sale and withdrawn. The ManoMano API returns only the code, price and stock for each offer, so the card gets little:
| ManoMano offer data | Product field in Elbuz |
|---|---|
| your offer code (SKU) | SKU; in a new card, also Name |
| price incl. VAT | Price |
| stock | Quantity |
| on sale or withdrawn | Status: an offer on sale means an enabled product |
An offer has no name, barcode, description or photos. So ManoMano works best with a catalog you already maintain in Elbuz: a run finds a card the template linked earlier by the offer code and updates its price, stock and status.
An unlinked offer becomes a new card named after its code, in a service category (service categories). It's easier to link existing cards to offers with an export by barcode — scenario.
To keep a run from touching a card at all, turn on “Do not update” in it (the “Import protection” section); to protect only prices, turn on “Fixed Price”.
How orders arrive and get accepted
An order arrives as an unposted “Customer order” document. The first import takes orders from the last 30 days. After that — orders changed since the last import, with a 12-hour margin. An existing order is recognized by its number and updated, not duplicated.
The document gets the number, creation and status change dates, the customer's name, phone and email, shipping and billing addresses, carrier, currency, shipping cost and items.
| Amount in the ManoMano order | How it goes into the document |
|---|---|
| item price | incl. VAT, as on the marketplace |
| your seller discount | spread across item prices in proportion to their amounts |
| ManoMano discount | not deducted: the marketplace pays for it, you get the full price |
| shipping | shipping cost minus the shipping discount |
The document total is the items plus shipping.
Automatic acceptance
Elbuz accepts orders on the marketplace itself when they are in PENDING status (awaiting your confirmation), during the same import. Stock availability isn't checked. An accepted order goes into the document with PREPARATION status.
If acceptance fails, the log shows a red line “ManoMano: order ‹number› was not accepted automatically — ‹reason›”, and the order is imported in PENDING status. The next import tries again: Elbuz picks up orders awaiting acceptance every time, regardless of the last import date.
The marketplace treats an accepted order as confirmed by you. If the product is out of stock, refuse the order with a status mapped to REFUSED (refusal) or in Toolbox.
Order statuses
Elbuz maps marketplace statuses to yours by itself — by code or name, and an unrecognized one becomes “New”. You can adjust this with the “Order statuses” button in the “Related settings” card of the import template: in the “Code (name) on site (API)” column, enter the ManoMano code next to your status.
| ManoMano code | Meaning |
|---|---|
PENDING | Awaiting acceptance by the seller |
PREPARATION | Accepted, being prepared for shipping |
SHIPPED | Shipped |
REFUSED | You refused the order |
REFUNDING | Refund to the customer in progress |
REFUNDED | Refunded |
The same mapping works in the other direction: a status mapped to SHIPPED, REFUSED or REFUNDED is sent to the marketplace by the export. If a cell holds several comma-separated codes, the first one is sent. What happens to a posted order and the reservation is described in importing orders via API.
How prices and stock go back to the marketplace
The reverse direction is a separate export template of the “ManoMano” type. It has two fields:
- Seller contract ID — the contract number. If it's empty, the contract is taken from the import template with the same key.
- API key — the same key from Toolbox.
The export takes the EAN search locale and carrier grid from this contract's import template.
1
Seller contract ID2
API key- Seller contract ID — leave empty: it is taken from the import template with the same key.
- API key — the same Toolbox key.
Products linked to the contract's offers are updated. Without the “Publish new products” checkbox, an unlinked product is skipped. What's sent to the marketplace:
- Price — incl. VAT, as a number from the export template, with two decimal places. Elbuz doesn't convert currency: prices in the filtered set must be in the contract's currency.
- Stock — the product quantity, not below zero.
- Which products — set by the export template's filtered set, as for other channels.
Prices and stock go in batches of up to a thousand offers. An offer whose price and stock haven't changed isn't counted as an error. The marketplace explains a rejected offer, and the log shows “ManoMano: «‹code›» rejected: ‹reason›”. The run summary is “ManoMano: prices and stock — succeeded: N, errors: M”.
Request limit
ManoMano allows about 200 requests per hour for offers and 250 for orders. Over the limit, Elbuz waits and retries. Failing that, the log shows “ManoMano: marketplace request limit exceeded, the rest will go on the next run”, and the next run sends the rest. So an hourly or rarer export is more reliable than one every few minutes.
The automatic orders pass uses at least 2 requests, which is about 24 of the 250 per hour.
New offers and new product pages
With the “Publish new products” checkbox, Elbuz lists an offer for a product that has no offer of yours on ManoMano yet. The offer attaches to an existing ManoMano product page by EAN, so the product needs a barcode of at least 8 digits. Elbuz first searches the catalog of the country from the “EAN search locale” field.
| What's found on ManoMano | What Elbuz does | Log line |
|---|---|---|
| a product page with this EAN | lists the offer and links the product | “ManoMano: offer «‹name›» (‹code›) published” |
| no product page | doesn't create the offer | “ManoMano: there is no page for «‹name›» (EAN ‹number›) on the marketplace — create it with a feed in Toolbox” |
| the page exists, but you can't sell on it | doesn't create the offer | “ManoMano: «‹name›» rejected: ‹marketplace reason›” |
| the product has no barcode | skips the product | “ManoMano: product «‹name›» has no barcode (EAN) — offer not created” |
A new offer gets the price, stock, product weight for shipping calculation, and the carrier grid from the import template. The offer code is the product SKU; without an SKU, the product ID in Elbuz.
If a feed import is running for the offers in Toolbox, the marketplace doesn't accept changes: the log shows “ManoMano: a feed import is running for these offers, not changed: N — retry on the next run”. No links are created, and the next run sends these products again.
How to create a new product page
ManoMano doesn't create new product pages via the API: they appear only from a feed you connect in Toolbox. Create a feed export in Elbuz with the products you need and enter its URL in Toolbox. Once the pages are created, the “ManoMano” export links your products to them by barcode and keeps their prices and stock updated.
Shipping, refusals and refunds
The “Orders” checkbox in the export template sends three events from your ManoMano orders to the marketplace:
| Your status mapped to | What Elbuz sends |
|---|---|
SHIPPED | Shipment with carrier and tracking number |
REFUSED | Order refusal |
REFUNDED | Refund for all items plus shipping, reason — out of stock |
The mapping is taken from the “Order statuses” window of the import template. The export handles orders from import templates of the same contract.
The tracking number is the “Delivery service: number” field in the document's “Delivery” card (expand “More fields”). The carrier comes from the import template's “Delivery types” button if a ManoMano carrier code is mapped there; otherwise Elbuz sends the delivery service name from the document, and without one — “Other”.
Each event is sent once: after sending, Elbuz remembers the new marketplace status. Orders already shipped, refused or being refunded on the marketplace aren't sent. The log shows lines “ManoMano: order ‹number› → SHIPPED” and the summary “ManoMano: order statuses sent: N, errors: M”. A marketplace rejection appears as “ManoMano: order ‹number› → SHIPPED not sent — ‹reason›”.
Scheduled updates
ManoMano doesn't send instant notifications, so Elbuz fetches and accepts orders by itself every 5 minutes if “Orders” is checked and the key is filled in. The shared “Marketplace orders” task in the “Job schedule” window does this; the interval is set there. This pass skips the catalog, and orders also picked up by the template schedule aren't duplicated.
The catalog is updated by the template's own schedule — the “Schedule setup” button in the “Related settings” card. Set it to run rarely, for example at night: while the catalog is running, the orders pass is skipped until the next one. Export prices and stock once an hour or less often because of the request limit.
The “Active” / “Disabled” badge takes the template off the schedule and out of automatic order fetching (disable a template).
A broken-off run is safe to repeat: the catalog is written in batches of 500 offers, and the date for the next batch of orders moves only after they are saved. General rules: if a run breaks off.
Scenarios
Accept orders and ship from Elbuz
What to turn on. In the import template — the key, Seller contract ID, the “Orders” checkbox, mapping via the “Order statuses” button (at least PREPARATION, SHIPPED, REFUSED); orders need no schedule — they arrive by themselves every 5 minutes. In the export template for the same contract — the “Orders” checkbox.
Result. New orders are accepted on the marketplace automatically. A manager enters the tracking number in “Delivery service: number” and sets the status mapped to SHIPPED — the next export sends the shipment.
ManoMano as a channel for a catalog you maintain in Elbuz
What to turn on. An export template with a filtered set of the products you need, and the “Products” and “Publish new products” checkboxes. The products must have barcodes. For products not yet on ManoMano — a feed export connected in Toolbox.
Result. Products whose pages already exist on ManoMano get your offers and links; after that, each run updates their price and stock. For the rest, the log tells you to create a page with a feed. In the import template, keep only “Orders” so the catalog run doesn't overwrite prices and stock with the marketplace's figures.
What to do when the marketplace doesn't send or accept data
| What you see | Why | What to do |
|---|---|---|
| “Connection failed: HTTP 401: …” | The key wasn't copied in full or was deleted in Toolbox | Create a new key in Toolbox and paste it into the import and export templates (what to get from Toolbox) |
| “ManoMano: enter the API key and Seller contract ID” | The key or contract number is empty | Fill in both template fields |
| “ManoMano: marketplace request limit exceeded…” | The hourly request limit is used up | The next run sends the rest; run the export less often (request limit) |
| “ManoMano: order ‹number› was not accepted automatically — …” | The marketplace refused acceptance | The next import tries again. If the line repeats, accept the order in Toolbox (acceptance) |
| “ManoMano: there is no page for «…» (EAN …) on the marketplace — create it with a feed in Toolbox” | The ManoMano API doesn't create new product pages | Connect a feed export in Toolbox (new product page) |
| “ManoMano: a feed import is running for these offers, not changed: N…” | Toolbox is processing your feed right now | Nothing: the next run sends these products again |
| The status was changed, but nothing went to the marketplace | The status isn't mapped to SHIPPED, REFUSED or REFUNDED, the export has no “Orders” checkbox, or it has a different contract |
Check the mapping in the import template and the checkbox in the export template (shipping) |
FAQ
Why are products imported from ManoMano named with codes?
The marketplace API doesn't return the offer name, only the code, price and stock. Link your cards to offers with an export by barcode (what goes into the card).
I sell in France and Spain — how many templates do I need?
A pair of templates per contract: import and export. One API key can be enough (where it is).
Can I turn off automatic order acceptance?
No, the ManoMano order import always accepts orders awaiting acceptance. If you don't want that, clear the “Orders” checkbox and accept orders in Toolbox (acceptance).
Does Elbuz create new product pages on ManoMano?
No, only offers on existing pages by barcode. The marketplace creates new pages from a feed in Toolbox (new product page).
I lost my API key — where can I find it?
Nowhere: Toolbox shows the key once. Create a new one and replace it in the templates (what to get from Toolbox).
Where it is and who has access
- Menu
- Directories → Operations → Data import → a new “ManoMano” type template
- Other entry points
- Directories → Operations → Data export — a template of the same type
- Access right
- the “Import” window in “Group permissions”
- Prepare
- an API key from Toolbox and the contract number (Seller contract ID)
One template is one ManoMano contract. If you sell in France and Spain or have two delivery methods, create as many templates as you have contracts. Product links are kept separately per contract and don't mix.
Related topics
- For the general import mechanics — schedule, broken-off runs, service categories: data import overview.
- If a manager handles orders in Elbuz and it matters what a run overwrites: importing orders via API.
- If you also sell on Leroy Merlin, Cdiscount or OTTO: connecting Mirakl, connecting Cdiscount, connecting OTTO.
