Odoo + n8n — Self-Hosted Workflow Automation

Why n8n for Odoo?

Odoo has built-in automation features — server actions, automated actions, scheduled actions. They work for simple triggers (“when a sale order is confirmed, send an email”). But they hit a wall fast:

• •No external integrations — Odoo's built-in automations live inside Odoo. If you want to post to Slack, update a Google Sheet, send a WhatsApp message, or call an external API, you are writing custom Python server actions and managing dependencies.
• •No visual workflow builder — automated actions are configured through form fields, not a workflow diagram. Complex multi-step logic is hard to build and harder to debug.
• •No error handling — if an automated action fails, it logs an error and moves on. There is no retry logic, no dead letter queue, no notification that something broke.
• •No cross-system orchestration — if your workflow involves Odoo + Slack + Stripe + a custom API, Odoo's built-in tools cannot handle that.

n8n solves all of this. It is a dedicated workflow engine that sits alongside Odoo and handles the orchestration layer. It connects to Odoo via XML-RPC (the same API that Odoo's own mobile app uses), and it connects to everything else via its 400+ built-in integration nodes.

Projects like OD8N.com have already proven there is a real market for Odoo + n8n. The combination works — and it works especially well for Odoo Community Edition users who do not have access to Enterprise's more advanced automation features.

n8n vs Zapier vs Make for Odoo

If you are evaluating automation platforms, here is how they compare:

For Odoo deployments, n8n is the clear winner if you are already self-hosting Odoo (which you are, if you are reading this). Adding one more Docker container to your stack costs nothing and gives you unlimited automation.

Docker Compose: Odoo + n8n Together

Here is a complete docker-compose.yml that runs Odoo, n8n, and PostgreSQL on the same server. Both services share a Docker network so n8n can reach Odoo's XML-RPC endpoint directly.

version: "3.8"

services:
  # -- PostgreSQL (shared database server) ----------------------
  postgres:
    image: postgres:16
    container_name: odoo-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: odoo
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-odoo_secret_change_me}
      POSTGRES_DB: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U odoo"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - odoo-network

  # -- Odoo -----------------------------------------------------
  odoo:
    image: odoo:18.0
    container_name: odoo
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      HOST: postgres
      PORT: 5432
      USER: odoo
      PASSWORD: ${POSTGRES_PASSWORD:-odoo_secret_change_me}
    ports:
      - "8069:8069"
      - "8072:8072"   # longpolling / websocket
    volumes:
      - odoo_data:/var/lib/odoo
      - odoo_addons:/mnt/extra-addons
      - ./odoo.conf:/etc/odoo/odoo.conf:ro
    networks:
      - odoo-network

  # -- n8n ------------------------------------------------------
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    environment:
      # n8n uses its own PostgreSQL database
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_PORT: 5432
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: odoo
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD:-odoo_secret_change_me}
      # n8n configuration
      N8N_HOST: ${N8N_HOST:-localhost}
      N8N_PORT: 5678
      N8N_PROTOCOL: https
      WEBHOOK_URL: ${WEBHOOK_URL:-https://n8n.yourdomain.com/}
      # Timezone -- match your Odoo timezone
      GENERIC_TIMEZONE: ${TIMEZONE:-UTC}
      TZ: ${TIMEZONE:-UTC}
      # Optional: enable community nodes
      N8N_COMMUNITY_PACKAGES_ENABLED: "true"
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - odoo-network

volumes:
  postgres_data:
  odoo_data:
  odoo_addons:
  n8n_data:

networks:
  odoo-network:
    driver: bridge

Create a .env file alongside the compose file:

POSTGRES_PASSWORD=your_secure_password_here
N8N_HOST=n8n.yourdomain.com
WEBHOOK_URL=https://n8n.yourdomain.com/
TIMEZONE=Europe/Berlin

Important notes

• •n8n and Odoo share the same PostgreSQL server but use separate databases. n8n creates its own n8n database automatically on first start.
• •Because both containers are on the odoo-network, n8n can reach Odoo at http://odoo:8069 (using the container name as hostname). No need to expose Odoo's port publicly for n8n to connect.
• •The WEBHOOK_URL must be the public URL where n8n receives webhook callbacks. This is critical for WhatsApp integration, Odoo webhook triggers, and any external service that needs to call into n8n.
• •You still need a reverse proxy (Nginx, Caddy, Traefik) in front of both services for SSL termination. Our Docker Compose Generator can generate a full config including the reverse proxy.

Start the stack:

# Create the n8n database (PostgreSQL must be running first)
docker compose up -d postgres
sleep 5
docker compose exec postgres createdb -U odoo n8n

# Start everything
docker compose up -d

Odoo is now available at http://localhost:8069 and n8n at http://localhost:5678.

Connecting n8n to Odoo

With both services running on the same Docker network, connecting them takes about two minutes.

Step 1: Create an API key in Odoo

For production, use an API key instead of a password. In Odoo:

1. Go to Settings → Users & Companies → Users
2. Select the user n8n will connect as (create a dedicated “n8n Integration” user if you prefer)
3. Go to the Account Security tab
4. Under API Keys, click “New API Key”
5. Name it “n8n” and copy the generated key — you will not see it again

Step 2: Configure the Odoo credential in n8n

1. Open n8n at http://localhost:5678
2. Go to Credentials → Add Credential → Odoo
3. Fill in:
   • Site URL: http://odoo:8069 (internal Docker network URL)
   • Username: the Odoo user's login (e.g., admin or n8n@yourcompany.com)
   • Password or API Key: paste the API key from step 1
   • Database Name: your Odoo database name (e.g., odoo)
4. Click Test Connection — you should see a green checkmark

Step 3: Verify available operations

Create a new workflow, add an Odoo node, and select the credential you just created. The Odoo node supports these operations on any Odoo model:

• •Create — insert a new record
• •Read — fetch a record by ID
• •Update — modify fields on an existing record
• •Delete — remove a record
• •Get All — search and return multiple records with domain filters
• •Generic Resource — access any Odoo model by technical name (e.g., sale.order, res.partner, helpdesk.ticket)

This means n8n can interact with every single model in your Odoo database — including custom modules.

10 Ready-to-Use Automation Workflows

Here are ten practical workflows. Each one describes the trigger, the logic, and the action. All of them can be built in n8n's visual editor without writing code.

Building Your First Workflow: Sale Order → Slack Notification

Let us build workflow #1 step by step. By the end, every confirmed sale order will trigger a Slack message.

Step 1: Create the webhook trigger in n8n

1. In n8n, create a new workflow and name it “Sale Order → Slack”
2. Add a Webhook node as the trigger
3. Set HTTP Method to POST
4. Set Path to odoo-sale-order (the full webhook URL will be https://your-n8n/webhook/odoo-sale-order)
5. Under Authentication, select Header Auth and set a secret token — we will use this to verify requests from Odoo
6. Save the node — n8n generates the webhook URL

Step 2: Configure Odoo to call the webhook

In Odoo, create a server action that fires on sale order confirmation:

1. Go to Settings → Technical → Server Actions (enable Developer Mode first)
2. Create a new server action:
   • Name: n8n - Sale Order Confirmed
   • Model: Sale Order (sale.order)
   • Action Type: Execute Python Code
3. Enter this code:

import json
import requests

for record in records:
    payload = {
        "event": "sale_order_confirmed",
        "order_id": record.id,
        "order_name": record.name,
        "partner_name": record.partner_id.name,
        "amount_total": record.amount_total,
        "currency": record.currency_id.name,
        "salesperson": record.user_id.name or "Unassigned",
        "date_order": str(record.date_order),
        "order_line_count": len(record.order_line),
    }
    try:
        requests.post(
            "https://your-n8n-domain.com/webhook/odoo-sale-order",
            json=payload,
            headers={
                "Authorization": "Bearer YOUR_SECRET_TOKEN",
                "Content-Type": "application/json",
            },
            timeout=10,
        )
    except Exception:
        pass  # Log errors in production -- do not block the sale order

Now create an Automated Action to trigger this server action:

• •Go to Settings → Technical → Automated Actions
• •Model: Sale Order
• •Trigger: On Update
• •Before Update Filter: [("state", "!=", "sale")]
• •Apply on: [("state", "=", "sale")]
• •Action: the server action you just created

Step 3: Add the Slack node in n8n

1. Back in n8n, add a Slack node after the Webhook node
2. Connect your Slack credential (Slack App with chat:write permission)
3. Configure:
   • Channel: #sales (or your preferred channel)
   • Message:

*New Sale Order Confirmed*

*Order:* {{ $json.order_name }}
*Customer:* {{ $json.partner_name }}
*Amount:* {{ $json.currency }} {{ $json.amount_total }}
*Salesperson:* {{ $json.salesperson }}
*Items:* {{ $json.order_line_count }} line(s)
*Date:* {{ $json.date_order }}

Step 4: Test and activate

1. In n8n, click “Listen for test event” on the Webhook node
2. In Odoo, confirm a test sale order
3. Verify the webhook fires and the Slack message appears
4. Activate the workflow

Exported workflow JSON

Here is the complete n8n workflow JSON — import this directly into n8n via Workflows → Import from File:

{
  "name": "Sale Order -> Slack Notification",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "odoo-sale-order",
        "authentication": "headerAuth",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [250, 300],
      "id": "webhook-1",
      "name": "Odoo Sale Webhook"
    },
    {
      "parameters": {
        "channel": "#sales",
        "text": "=*New Sale Order Confirmed*\n\n*Order:* {{ $json.order_name }}\n*Customer:* {{ $json.partner_name }}\n*Amount:* {{ $json.currency }} {{ $json.amount_total }}\n*Salesperson:* {{ $json.salesperson }}\n*Items:* {{ $json.order_line_count }} line(s)\n*Date:* {{ $json.date_order }}",
        "otherOptions": {}
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2.2,
      "position": [500, 300],
      "id": "slack-1",
      "name": "Post to Slack"
    }
  ],
  "connections": {
    "Odoo Sale Webhook": {
      "main": [
        [
          {
            "node": "Post to Slack",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  }
}

Advanced: AI-Powered Workflows

n8n has native nodes for OpenAI, Anthropic Claude, and Ollama (local LLMs). This opens up workflows that were impossible with Odoo alone.

Classify incoming emails → Route to the right department

Email Trigger (IMAP or Gmail node)
    -> Extract subject + body
    -> OpenAI node: "Classify this email into: billing, technical_support,
      sales_inquiry, partnership, spam. Return only the category."
    -> Switch node: route based on classification
    -> Odoo node: create lead (sales), helpdesk ticket (support),
      or discard (spam)

Summarize customer interactions before a meeting

Manual Trigger (or Cron before daily standup)
    -> Odoo node: fetch all activities/messages for partner in last 30 days
    -> Claude/OpenAI node: "Summarize this customer's recent interactions
      in 3 bullet points. Note any open issues or pending quotes."
    -> Slack node: post summary to #sales-prep channel

Auto-generate product descriptions

Odoo Trigger: new product created with empty description
    -> Fetch product name, category, attributes
    -> OpenAI node: "Write a concise product description (2-3 sentences)
      for an e-commerce store. Product: {{name}}, Category: {{category}},
      Attributes: {{attributes}}"
    -> Odoo node: update product description field

For more AI + Odoo patterns, including how to bring AI features to Community Edition, see our AI for Odoo Community guide.

Webhook Integration: Odoo → n8n

The sale order example above showed one webhook pattern. Here is a reusable server action template you can adapt for any Odoo model.

Generic webhook server action

Create this as a reusable server action and call it from any automated action:

import json
import requests

# Configuration -- change these per use case
WEBHOOK_URL = "https://n8n.yourdomain.com/webhook/odoo-events"
AUTH_TOKEN = "your_secret_token"

for record in records:
    payload = {
        "event": env.context.get("n8n_event", "record_updated"),
        "model": record._name,
        "record_id": record.id,
        "record_name": record.display_name,
        "timestamp": str(fields.Datetime.now()),
        # Add model-specific fields as needed
        "data": {
            "state": getattr(record, "state", None),
            "partner_id": record.partner_id.id if hasattr(record, "partner_id") else None,
            "partner_name": record.partner_id.name if hasattr(record, "partner_id") else None,
            "amount_total": getattr(record, "amount_total", None),
            "user_id": record.user_id.id if hasattr(record, "user_id") else None,
        },
    }
    try:
        requests.post(
            WEBHOOK_URL,
            json=payload,
            headers={
                "Authorization": f"Bearer {AUTH_TOKEN}",
                "Content-Type": "application/json",
            },
            timeout=10,
        )
    except Exception as e:
        # In production, log this properly
        record.message_post(
            body=f"n8n webhook failed: {str(e)}",
            message_type="notification",
        )

Setting up the automated action

For each event you want to send to n8n:

1. Settings → Technical → Automated Actions
2. Pick the model (Sale Order, Invoice, Helpdesk Ticket, etc.)
3. Set the trigger condition (On Creation, On Update with filter, etc.)
4. Link to the server action above

Scheduling & Batch Processing

Not everything should be event-driven. Some workflows run on a schedule.

n8n Cron triggers

n8n's Schedule Trigger node supports:

• •Every N minutes/hours — for polling-style workflows
• •Cron expression — for precise scheduling (e.g., 0 9 * * 1-5 for weekdays at 9 AM)
• •Specific times — daily at 8 AM, weekly on Monday, monthly on the 1st

Common scheduled workflows

Nightly data sync: Odoo → external system

Schedule: 2 AM daily
    -> Odoo node: Get All records modified today
      (filter: write_date >= today 00:00)
    -> Transform data to target format
    -> HTTP Request: POST to external API
    -> Log sync results

Weekly sales digest

Schedule: Monday 8 AM
    -> Odoo: Get all sale orders from last 7 days
    -> Aggregate: total revenue, order count, top products, top salespeople
    -> Format HTML email
    -> Send via SMTP/SendGrid

Monthly cleanup: archive stale leads

Schedule: 1st of month, 3 AM
    -> Odoo: Get All CRM leads where stage = 'New'
      AND create_date < 90 days ago AND no activity in 60 days
    -> Odoo: Update each lead -- set active = false
    -> Slack: post summary "Archived X stale leads"

Batch processing tips

When processing large datasets from Odoo, keep these in mind:

• •Use pagination — the Odoo node's “Get All” operation supports limit and offset. Process in batches of 100–500 records.
• •Add delays between batches — a Wait node with 1–2 second delay prevents overwhelming Odoo's XML-RPC endpoint.
• •Use the SplitInBatches node — n8n has a built-in node for processing items in configurable batch sizes with automatic looping.
• •Set a reasonable timeout — n8n workflow executions have a default timeout. For large batch jobs, increase it in the workflow settings.

Monitoring & Error Handling

Production workflows need to be reliable. n8n has built-in tools for this.

Execution logs

Every workflow execution is logged in n8n with:

• •Start time, end time, duration
• •Status (success, error, waiting)
• •Input and output data for every node
• •The exact error message and stack trace if something failed

Access logs at Executions in the n8n sidebar. Filter by workflow, status, and date range.

Error workflows

n8n has a dedicated Error Trigger node. Create a separate “Error Handler” workflow:

{
  "name": "Error Handler -> Slack Alert",
  "nodes": [
    {
      "parameters": {},
      "type": "n8n-nodes-base.errorTrigger",
      "typeVersion": 1,
      "position": [250, 300],
      "id": "error-1",
      "name": "On Workflow Error"
    },
    {
      "parameters": {
        "channel": "#ops-alerts",
        "text": "=Workflow failed: {{ $json.workflow.name }}\nNode: {{ $json.execution.lastNodeExecuted }}\nError: {{ $json.execution.error.message }}\nExecution: {{ $json.execution.url }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2.2,
      "position": [500, 300],
      "id": "slack-alert-1",
      "name": "Alert Slack"
    }
  ],
  "connections": {
    "On Workflow Error": {
      "main": [
        [
          {
            "node": "Alert Slack",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

Then in each production workflow's settings, set the Error Workflow to your error handler. Now any failure in any workflow posts an alert to Slack with the workflow name, failing node, and error message.

Retry logic

For nodes that call external APIs (including Odoo), enable retry on error:

• •In the node settings, set Retry on Fail to true
• •Set Max Retries to 3
• •Set Wait Between Retries to 1000ms (or more for rate-limited APIs)

For more sophisticated retry patterns — exponential backoff, different retry strategies per error type — use a combination of the IF node (check error type) and Wait node (variable delay) in a retry loop.

Self-Hosted vs Cloud n8n

n8n offers both options. Here is how they compare for Odoo users:

The only case for n8n Cloud is if you have no DevOps capacity and cannot manage another container. In that case, n8n Cloud works fine — just note that n8n will reach Odoo over the public internet, so your Odoo instance needs to be accessible (with proper authentication) from n8n's IP ranges.

Server resources

n8n is lightweight. For a typical Odoo deployment's automation needs:

• •CPU: 0.5 cores (n8n is mostly I/O-bound, waiting on API calls)
• •RAM: 256–512 MB (more if you process large datasets in workflows)
• •Disk: 1–2 GB (for n8n application + execution logs)

If you are running Odoo on a 4 GB / 2 vCPU server, adding n8n barely registers. On a 2 GB / 1 vCPU server, you might notice it during batch processing — in that case, run n8n on a separate small server or bump your server specs. Use our Server Requirements Calculator to size appropriately.

Deploy Odoo + n8n on OEC.sh

Running Odoo and n8n together means managing two services, their database connections, SSL certificates, reverse proxy configuration, backups, and updates. OEC.sh handles all of that on the cloud provider of your choice.

What you get:

• Odoo + n8n on the same server with internal networking already configured
• Any cloud provider — AWS, Hetzner, DigitalOcean, or your own infrastructure. No vendor lock-in.
• SSL certificates provisioned and renewed automatically — required for n8n webhooks
• Automated backups of both Odoo and n8n data
• One-click updates for both services

Start with our Docker Compose Generator to preview the configuration, or see pricing for fully managed deployment.

Frequently Asked Questions