OTTO Market Marketplace Connector

Key Features

Dedicated `otto.backend` model holding credentials, environment (sandbox/production), rate-limit settings and per-channel defaults, with a connection test action

Scheduled order import via `ir.cron` with a configurable window and a manual 'Sync now' button, creating `sale.order` records with external OTTO identifiers stored for idempotent re-runs

Explicit marketplace status mapping (announced, processable, sent, returned, cancelled) onto Odoo's sale/picking state machine plus a searchable channel status field on the order

SKU mapping model linking OTTO listing identifiers to `product.product`, so mapping is data-driven instead of relying on internal reference conventions

Real-time stock push with computed available quantity using `@api.depends` on `stock.quant`, plus per-SKU and per-warehouse safety-buffer fields to prevent overselling

Delta-only synchronisation queue: only SKUs whose sellable quantity or price actually changed are pushed, keeping you inside OTTO API rate limits

Price synchronisation driven by a nominated Odoo pricelist, with optional per-channel markup rules and currency handling

Listing export from `product.template` with configurable OTTO category mapping and `product.attribute` to marketplace-attribute mapping, including variant structure

Automatic shipment confirmation and carrier tracking push-back on `stock.picking` validation, with per-carrier code mapping for OTTO's accepted shipping providers

Return and cancellation handling that creates the corresponding Odoo return picking or cancellation and reflects it on the sales order chatter

Settlement import that reconciles payouts into draft `account.move` entries, splitting commission, fulfilment and return fees onto separate accounts with analytic distribution

Full request/response logging model with error queue, retry counters and a resend action, so failed calls are visible and replayable from the Odoo backend

Security via `ir.model.access.csv` and record rules for a dedicated Marketplace Operator group, plus multi-company record rules where you run more than one company

Odoo list, form, kanban and filter views for marketplace orders, mappings and logs, with QWeb report and dashboard extensions available in scope

Delivered for Odoo 17.0, 18.0 or 19.0 with the `__manifest__.py` pinned to your series; works on Community and integrates with Enterprise accounting where present

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your Odoo.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

Selling on OTTO Market usually means running two systems that disagree with each other. Orders arrive in the OTTO partner portal, get copied by hand or by CSV into Odoo, and by the time the picking is validated the marketplace stock figure is already stale. Overselling on a fast-moving SKU triggers cancellations and performance penalties; underselling quietly hides inventory you already own. At month end, finance is left reconciling a single payout against dozens of order lines, commission charges, shipping fees and returns with no audit trail in account.move. Odoo core has no concept of a marketplace channel at all — sale.order has no external reference lifecycle, stock.quant has no notion of a channel-reserved buffer, and there is no scheduled job that talks to OTTO. Even the Enterprise e-commerce apps assume you own the storefront, which on a marketplace you do not.

What we build is a first-class Odoo integration, not a spreadsheet bridge. A dedicated otto.backend model holds credentials, environment and per-channel defaults, and every synced document carries an external identifier and a channel reference so a marketplace order is traceable back to OTTO forever. Order import runs on an ir.cron job (and can be triggered manually) that pulls new and updated orders, resolves or creates the customer partner, maps OTTO SKUs to product.product through a mapping model rather than by guessing on internal reference, and creates the sale.order with the right pricelist, fiscal position and warehouse. Marketplace statuses are mapped explicitly — announced, processable, sent, returned, cancelled — onto Odoo's own state machine plus a channel status field, so operations can filter a list view by what OTTO thinks is true, not just what Odoo thinks is true.

Stock and price synchronisation runs the other way. Computed fields with @api.depends on the relevant stock.quant and pricelist inputs derive the sellable quantity per listing, apply a per-SKU or per-warehouse safety buffer, and queue a delta push so OTTO is only told about SKUs that actually changed. Listing export builds the OTTO payload from product.template and product.attribute values through a configurable category and attribute mapping, so your Odoo attributes drive the marketplace variant structure instead of being retyped. When a picking is validated, shipment confirmation and the carrier tracking reference are pushed back automatically, which is what protects your on-time delivery metrics. Settlement files are imported and reconciled into draft journal entries with commission, fulfilment and return fees on separate accounts and analytic distribution, so the payout in your bank statement matches a posted entry line by line. Everything is wrapped in a request/response log model with retry and error queues, ir.model.access.csv entries plus record rules for a marketplace-operator group, and Odoo list/form/OWL views so no one has to read a log file to find out why an order failed. The module is delivered for your exact series — 17.0, 18.0 or 19.0 — with the __manifest__.py pinned to it, and it works on Community; where Enterprise features such as advanced accounting reporting or Studio-built fields exist, we integrate with them rather than duplicating them.

This is a build-to-order product. There is no instant download and we do not pretend otherwise. You request a quotation, we run a scoping call, and we confirm the specifics that actually change the code: your Odoo version and hosting, whether you are single- or multi-warehouse, how your OTTO SKUs relate to your Odoo variants, which OTTO API credentials and scopes you can provide, and how you want fees posted in your chart of accounts. From confirmed scope, typical delivery is 2 to 4 weeks. We build against your Odoo version, deliver to a staging database first for UAT with your own catalogue and a real OTTO sandbox or limited-scope account, and only then go live with an agreed rollback plan.

You receive the full source, a git repository handover, and documentation written for both your developer and your operations team. Because the marketplace API and your business both move, we also agree a post-go-live support window up front and can quote an ongoing maintenance arrangement covering OTTO API changes and Odoo version upgrades.

What you get

Installable Odoo module source code built and tested for your exact Odoo version (17.0, 18.0 or 19.0), Community or Enterprise

Installation and configuration on your environment, including OTTO credential setup, cron scheduling, category/attribute mapping and journal/account configuration

Technical documentation: data model, mapped fields, API endpoints used, cron jobs, security groups and extension points for your developers

End-user guide plus a live training session for your marketplace operations and finance teams

UAT on a staging database with your own catalogue and a documented go-live checklist with a rollback plan

Post-go-live support window agreed in the quotation, covering defects and configuration questions

Git repository handover with full commit history, so the code is yours to maintain or extend

Optional ongoing maintenance quotation covering OTTO API changes and Odoo version upgrades

Who this is for

Marketplace operations manager

Runs day-to-day OTTO selling and is tired of re-keying orders and firefighting oversells. Needs every OTTO order to land in Odoo automatically with the correct status, and needs stock pushed back fast enough that listings never promise inventory that has already shipped elsewhere.

E-commerce or channel manager

Owns the catalogue across several sales channels and needs OTTO listings to be generated from the same Odoo product data as everything else. Cares about category and attribute mapping, variant structure and pricing rules being configurable rather than hard-coded.

Finance controller or accountant

Has to explain a single OTTO payout against hundreds of order lines and assorted fees. Needs settlement reconciliation into draft journal entries with commission and fulfilment fees on their own accounts, so the bank statement ties out without a spreadsheet.

IT lead or Odoo administrator

Responsible for the Odoo instance and any custom code on it. Wants a properly structured module with real access rights, logging and documentation, delivered as source in a git repository rather than an obfuscated black box they cannot upgrade.

How OTTO Market Marketplace Connector Compares

Criterion	ECOSIRE	Custom Build	Competitor	Odoo Native
Fit to your Odoo setup	Built against your exact version, warehouses, SKU scheme and chart of accounts	Fully bespoke, but you fund every design decision from a blank page	Generic assumptions; you bend your setup to fit the module	No marketplace channel concept exists in Odoo core
OTTO order import	Scheduled `ir.cron` import with idempotent external IDs and explicit status mapping	Possible, but the status state machine is where most DIY builds break	Often present, though status mapping is frequently partial	Manual entry or CSV import with no channel traceability
Stock accuracy	Delta pushes from computed `stock.quant` availability with safety buffers	Depends entirely on how carefully rate limits and buffers were designed	Usually a fixed-interval full push, so gaps between cycles remain	No push at all; marketplace figures are updated by hand
Settlement and fee reconciliation	Draft journal entries with commission, fulfilment and return fees split by account	Commonly descoped late because accounting mapping is the slow part	Rarely covered beyond a simple payout total	Manual reconciliation of one payout against many order lines
Time and cost to live	2 to 4 weeks from confirmed scope, on a fixed quotation	Longer discovery and build; cost scales with the unknowns	Fast to install, slow to bend once the mismatch surfaces	No build time, but permanent manual effort
Code ownership	Full source plus git repository handover, yours to extend	You own it, and you own all of its maintenance	Vendor-controlled release cycle; often no repository access	Nothing to own
Upgrade path across Odoo versions	Version-pinned build, with upgrade work quotable under maintenance	Every major upgrade is a fresh project unless it was built for one	Dependent on whether the vendor ports to your next version	Not applicable
Support when something breaks	Named support window, plus a log and retry queue visible in the Odoo backend	Whoever built it, if they are still available	Ticket queue with no visibility into your data	Internal effort only

Frequently Asked Questions about OTTO Market Marketplace Connector

How long does delivery take, and can I download it today?

No, this is a build-to-order product rather than an existing apps.odoo.com download. After you request a quotation we run a short scoping call, confirm the specifics (Odoo version, warehouses, SKU mapping, API credentials, fee accounting), and then build it. Typical delivery is 2 to 4 weeks from confirmed scope, including UAT on a staging database before go-live.

Which Odoo versions do you support, and does it need Enterprise?

We build for Odoo 17.0, 18.0 and 19.0, with the `__manifest__.py` pinned to your series. The connector works on Community — nothing in the core sync depends on Enterprise. Where you already run Enterprise accounting or Studio-built fields, we integrate with them rather than duplicating functionality.

What do you need from me before you can start building?

OTTO partner API credentials with the relevant scopes (or sandbox access), your Odoo version and hosting details, a sample of how your OTTO SKUs relate to your Odoo variants, your warehouse setup, and the accounts and journals you want commission and fulfilment fees posted to. If any of that is not ready yet, we scope around it and confirm before build starts.

How does the connector stop us from overselling?

Sellable quantity is a computed field derived from `stock.quant` with a configurable safety buffer per SKU or per warehouse, and it is pushed to OTTO as a delta whenever it changes rather than on a slow full-catalogue cycle. You can also exclude specific warehouses or locations from the calculation so a returns or quarantine location never inflates the marketplace figure.

What happens with settlements and marketplace fees?

Settlement data is imported and reconciled into draft `account.move` entries, with commission, fulfilment and return fees split onto separate accounts and, if you use them, analytic distributions. Entries are created as drafts so your accountant reviews and posts them — we never post directly to your ledger without a human step.

What support and updates do we get after go-live?

Every quotation includes a defined post-go-live support window for defects and configuration questions. Beyond that we can quote an ongoing maintenance arrangement covering OTTO API changes and Odoo version upgrades. Because you receive the full source and a git repository, you are also free to maintain or extend it in-house.

Can this be extended to other marketplaces or to our own customisations?

Yes. The module is structured around a backend model, mapping models and a logging layer, so additional channels or custom rules are additive rather than a rewrite. It can also be extended through Odoo's standard mechanisms — inheriting models, automated actions, or your own module talking to it over the XML-RPC/JSON-RPC API or directly through the ORM.