Skip to main content
Odoo // API integration

Your systems should talk. Politely, and with retries.

We connect Odoo to commerce, payment, logistics, banking, and internal systems, and replace brittle point-to-point scripts with integrations that survive slow APIs and bad data.

Protocols
REST · JSON-RPC · Webhooks
Patterns
Sync · Async · Batch
Guarantees
Idempotent, observable

Define who owns each field. Make every sync idempotent. Monitor the boring parts.

Integrations fail quietly

A broken integration rarely announces itself. Orders stop arriving, stock levels drift, a payment never reconciles, and someone notices days later when a customer complains. The original script worked fine in testing; it just never planned for the API being slow, returning an error, or sending the same event twice.

Good integrations are designed for those days. Each record has one system that owns it, every message can be safely retried, failures land in a queue someone actually watches, and a nightly reconciliation proves both sides still agree.

Platforms we commonly connect

If it has an API, it can be integrated. If it only has a CSV export, we can still help, with a sigh.

Commerce

  • Shopify
  • WooCommerce
  • Magento
  • Amazon

Payments & finance

  • Stripe
  • PayPal
  • Bank feeds
  • Xero
  • QuickBooks

CRM & marketing

  • HubSpot
  • Salesforce
  • Mailchimp

Logistics

  • 3PL APIs
  • Carrier APIs
  • EDI files

Decide who owns each field

Most sync bugs come from two systems editing the same data. We agree an owner for every field before writing code.

DataUsual ownerDirection
Products & pricesOdooOdoo → storefronts
Stock levelsOdooOdoo → storefronts, with safety buffers
Web ordersStorefrontStorefront → Odoo
Shipment trackingCarrier or 3PLCarrier → Odoo → customer
PaymentsPayment providerProvider → Odoo, reconciled to invoices
Customer contactsAgreed per businessWritten down explicitly

Pick the right pattern

PatternUse whenTrade-off
WebhooksThe source pushes events in real timeNeeds signature checks and duplicate handling
Scheduled pollingThe source has no eventsDelay between change and sync
Message queueHigh volume or many consumersMore infrastructure to run
Batch / fileLegacy systems and bulk loadsNot real time; needs reconciliation

Idempotent by default

Webhooks arrive twice, out of order, or not at all. Every handler verifies the sender and ignores events it has already processed.

webhooks/shopify_orders.pypython
@router.post("/webhooks/shopify/orders")
async def shopify_order_created(request: Request, db: Session = Depends(get_db)):
    verify_shopify_signature(request)          # reject forged calls
    payload = await request.json()

    if order_exists(db, payload["id"]):        # idempotency guard
        return {"status": "duplicate"}

    odoo_id = odoo.create_sale_order(transform_order(payload))
    log_sync_event(db, payload["id"], odoo_id)  # audit trail
    return {"status": "created", "odoo_id": odoo_id}

How we deliver an integration

  1. Step 01

    Map

    Document systems, fields, owners, volumes, and the business events that trigger a sync.

  2. Step 02

    Design for failure

    Decide retries, timeouts, dead-letter handling, and what happens when either side is down.

  3. Step 03

    Build & test

    Implement against sandbox accounts with automated tests for duplicates, out-of-order events, and bad data.

  4. Step 04

    Reconcile

    Add reports that compare both systems and flag drift before customers notice.

  5. Step 05

    Monitor

    Dashboards and alerts on failures, latency, and queue depth, with a runbook for support.

Why integrations break

Myth: The API will always respond.

Reality: It won't. Timeouts, retries with backoff, and a dead-letter queue are part of the design.

Myth: Both systems can edit the same field.

Reality: That's a conflict generator. Each field gets one owner, written down.

Myth: No errors means it's working.

Reality: Silent failures are the worst kind. We add reconciliation reports and alerts.

Idempotency, explained with coffee

If "idempotent" sounds like jargon, our short article explains why retried requests create duplicate orders and how a simple receipt number prevents it.

How Odoo's external API works

Odoo exposes its models to other systems through an external API. Anything a user can do in the interface, such as creating an order, reading stock, or posting an invoice, can be done programmatically by an API user, subject to the same access rights.

That's powerful and easy to misuse. We give every integration its own API user with only the permissions it needs, avoid chatty record-by-record calls in favor of batched requests, and use the API style supported and recommended for your Odoo version.

Common integration recipes

Shopify or WooCommerce

Orders flow into Odoo, stock and prices flow out, fulfillment and tracking flow back to the customer.

Stripe and payment providers

Payments and payouts reconciled to invoices, with fees booked to the right accounts.

Bank feeds

Statements imported daily and matched to invoices by reconciliation rules.

3PL and carriers

Shipments sent to the warehouse partner, with stock and tracking updates returned to Odoo.

Error-handling playbook

Every integration ships with an agreed response to each kind of failure.

FailureAutomatic responseHuman follow-up
Timeout or 5xx errorRetry with backoffAlert if retries are exhausted
Rate limitedSlow down and queueNone unless sustained
Invalid dataPark the message in a review queueFix the record and replay
Duplicate eventIgnore via idempotency keyNone
Auth expiredStop the sync and alertRenew credentials

Before an integration goes live

  • Field ownership agreed and documented
  • Sandbox tests for duplicates, failures, and bad data
  • Alerts routed to someone who will act on them
  • Reconciliation report scheduled
  • Runbook for replaying failed messages
  • Credentials stored in a vault, rotated on a schedule

Plan for volume, not just for the happy path

An integration that handles ten orders an hour can fall over at a thousand. We size every integration for its peaks, such as seasonal sales, month-end, or a bulk catalog update, and design accordingly: batching writes into Odoo, queueing bursts instead of processing them inline, and spreading heavy syncs outside business hours.

We also plan for the initial load. The first sync of a catalog or customer base is usually much bigger than daily traffic, so it gets its own import process, separate from the live integration.

Facts to check before you design an integration

Odoo's external API exposes models over XML-RPC, and API keys can be used in place of a password for authenticationSource [1]. Check your plan early: Odoo's documentation states that data access through the external API is only available on Custom pricing plans, not on One App Free or Standard plansSource [1]. On-premise and Odoo.sh setups have their own considerations, which we confirm in discovery.

Networks drop responses, and clients retry. The HTTP standard notes that a client should not automatically retry a non-idempotent request unless it has a way to know repeating it is safeSource [2]. Mature APIs solve this with idempotency keys: the server stores the first result for a key and returns it on repeats, and rejects a reused key with different parametersSource [3]. We build every integration this way, plus logging and reconciliation, so a retry never becomes a duplicate order.

Already using n8n, Make, or Zapier?

Keep what works. We often leave simple automations in place and move only the high-volume or business-critical flows into tested, monitored code, so you get reliability where it matters without rebuilding everything.

Frequently asked questions

Do you support EDI?
Yes. EDI documents such as orders, invoices, and despatch advice can be exchanged through file-based flows or EDI providers, mapped to Odoo records with validation and acknowledgements.
How long does an integration take to build?
Simple connectors with a mature API take far less time than integrations with legacy systems, complex mapping, or high volumes. Mapping and failure design are scoped first, which makes the estimate reliable.
Can you take over an existing integration?
Yes. We review the code, add logging and reconciliation if they're missing, and fix the failure handling before adding features.
Do you use Odoo's built-in API or build custom endpoints?
Both. Odoo's external API covers most reads and writes; custom controllers make sense for webhooks and specialized endpoints. We follow the API style supported by your Odoo version.
What about tools like n8n or Zapier?
They're great for simple, low-volume flows. High-volume or business-critical sync usually needs code with tests, retries, and monitoring.
How do you handle API rate limits?
Queues, batching, and backoff that respect each provider's limits, so bursts like a flash sale don't get requests rejected.
Can you integrate a legacy system with no API?
Often, through database views, file exchange, or a small adapter service that exposes a clean API on its behalf.
Where does the integration code run?
Inside Odoo as a module for simple cases, or as a separate service when volumes, retries, or several systems are involved. We'll recommend one based on your load and hosting.
How do we know the systems agree?
Scheduled reconciliation reports compare key records and totals across systems and alert on differences.
Who monitors integrations after launch?
You get dashboards, alerts, and a runbook; support plans can include monitoring and incident response by our team.
What about security?
Signed webhooks, scoped API keys per integration, secrets in a vault, and logs that never store card data or passwords.
Can we use Odoo's API on any plan?
Not on every plan. Odoo's documentation says external API data access is only available on Custom pricing plans for Odoo OnlineSource [1]. We'll check your setup before designing anything.
How do you prevent duplicate orders from retries?
With idempotency: each operation carries a unique key, and the receiving side recognizes repeats instead of creating a second recordSource [2]Source [3].