Sendinblue to Odoo Integration: Complete 2025 Guide

Integration Architecture and Data Flow

The Sendinblue and Odoo 18 integration employs a webhook-driven, event-based architecture. This design ensures real-time data exchange without constant polling. Odoo acts as the system of record for contact data, while Sendinblue serves as the outbound marketing execution engine. The entire flow depends on a secure, bidirectional API communication channel.

Core Synchronization Components

Your integration relies on three primary components. The Odoo module, typically a custom-developed or configured connector, handles internal event triggers. The Sendinblue API receives contact data and triggers email campaigns. A webhook endpoint, hosted within your Odoo instance, processes event notifications from Sendinblue. These components form a continuous data feedback loop.

Outbound Data Flow: Odoo to Sendinblue

When a contact updates in Odoo, the connector captures the change. This trigger occurs after a partner creation, a field update, or a stage change in a sales order. The module packages this data into a JSON payload structured for the Sendinblue Contacts API. It then executes a POST request to `https://api.sendinblue.com/v3/contacts` to create or update the contact record in Sendinblue. This flow keeps your marketing lists current with CRM changes.

Inbound Data Flow: Sendinblue to Odoo

Sendinblue sends engagement data back to Odoo via configured webhooks. When a recipient opens an email, clicks a link, or unsubscribes, Sendinblue generates an event. It sends a POST request with event details to your Odoo webhook URL. The Odoo webhook controller parses this JSON payload and updates the corresponding partner record. This process enriches Odoo contact profiles with vital marketing engagement metrics.

Data Flow Patterns and Timing

The architecture supports both real-time and batch processing. Critical events like new lead creation or unsubscriptions process immediately for operational integrity. Large historical data imports or list synchronizations may run as scheduled batch jobs to prevent API rate limiting. You must implement a retry mechanism for failed API calls, storing payloads in a queue for subsequent processing. This hybrid approach balances performance with reliability.

Step-by-Step Configuration

Prerequisites and Environment Setup

Begin by gathering your API credentials. Log into your Sendinblue account, navigate to the SMTP & API section, and generate a new v3 API key. Grant this key full permissions for contacts, transactional emails, and webhooks. In your Odoo 18 instance, ensure you have developer mode activated and the base and contacts modules installed. You need administrative access to install custom modules and configure system parameters.

Install any required Python libraries. The Sendinblue integration depends on the sib-api-v3-sdk package. Install it using pip: pip install sib-api-v3-sdk. Verify your Odoo server can make outbound HTTPS requests. Check your firewall rules and ensure no network policies block communication with api.sendinblue.com on port 443. This preparation prevents common connectivity issues.

Creating the Odoo Custom Module

Start by creating a new Odoo module structure. Create a module named sendinblue_connector with the essential files: __init__.py, __manifest__.py, models/models.py, and controllers/controllers.py. Define your module metadata in the manifest file. Specify a descriptive name, version, and dependencies on Odoo’s contacts and base modules.

# __manifest__.py
{
    'name': 'Sendinblue Connector',
    'version': '18.0.1.0.0',
    'category': 'Marketing',
    'summary': 'Integrate Odoo 18 with Sendinblue',
    'depends': ['base', 'contacts', 'mail'],
    'data': [
        'security/ir.model.access.csv',
        'views/res_config_settings_views.xml',
        'views/res_partner_views.xml',
    ],
    'installable': True,
    'application': True,
}

Implementing Configuration Settings

Create a configuration model to store API credentials securely. Extend the res.config.settings model to add fields for your Sendinblue API key and webhook secret. Store the API key in an ir.config_parameter for secure retrieval. Never hardcode credentials in your model logic.

from odoo import models, fields, api

class ResConfigSettings(models.TransientModel):
    _inherit = 'res.config.settings'

    sendinblue_api_key = fields.Char(string='API Key', config_parameter='sendinblue.api_key')
    sendinblue_webhook_secret = fields.Char(string='Webhook Secret', config_parameter='sendinblue.webhook_secret')

    def set_values(self):
        super(ResConfigSettings, self).set_values()
        self.env['ir.config_parameter'].set_param('sendinblue.api_key', self.sendinblue_api_key)

    @api.model
    def get_values(self):
        res = super(ResConfigSettings, self).get_values()
        res.update(
            sendinblue_api_key=self.env['ir.config_parameter'].get_param('sendinblue.api_key'),
        )
        return res

Building the Sendinblue API Client

Create a dedicated model to handle all Sendinblue API interactions. This model centralizes your API calls and implements error handling. Use the Sendinblue Python SDK for reliable API communication.

import logging
from sib_api_v3_sdk import Configuration, ApiClient, ContactsApi
from sib_api_v3_sdk.rest import ApiException

_logger = logging.getLogger(__name__)

class SendinblueAPI(models.Model):
    _name = 'sendinblue.api'
    _description = 'Sendinblue API Client'

    def _get_api_client(self):
        """Initialize and return the Sendinblue API client."""
        api_key = self.env['ir.config_parameter'].get_param('sendinblue.api_key')
        if not api_key:
            _logger.error("Sendinblue API key not configured")
            return None

        config = Configuration()
        config.api_key['api-key'] = api_key
        return ApiClient(config)

    def create_contact(self, email, attributes=None, list_ids=None):
        """Create or update a contact in Sendinblue."""
        api_client = self._get_api_client()
        if not api_client:
            return False

        contacts_api = ContactsApi(api_client)
        create_contact = CreateContact(
            email=email,
            attributes=attributes or {},
            list_ids=list_ids or [],
            update_enabled=True
        )

        try:
            contacts_api.create_contact(create_contact)
            _logger.info("Synced contact %s to Sendinblue", email)
            return True
        except ApiException as e:
            _logger.error("Sendinblue API exception: %s", e)
            return False

Configuring Odoo Webhooks

Create a webhook controller in Odoo to receive Sendinblue events. This controller must validate the webhook signature to prevent spoofing. Implement endpoints for different event types like email opens, clicks, and unsubscribes.

from odoo import http
from odoo.exceptions import ValidationError
import json
import hmac
import hashlib

class SendinblueWebhookController(http.Controller):

    @http.route('/sendinblue/webhook', type='json', auth='public', methods=['POST'], csrf=False)
    def webhook_listener(self):
        """Receive and process Sendinblue webhook events."""
        secret = http.request.env['ir.config_parameter'].get_param('sendinblue.webhook_secret')
        request_data = json.loads(http.request.httprequest.data)
        signature = http.request.httpheaders.get('X-Sendinblue-Signature')

        # Validate webhook signature
        if not self._verify_signature(secret, http.request.httprequest.data, signature):
            _logger.warning("Invalid webhook signature received")
            raise ValidationError("Invalid signature")

        event_type = request_data.get('event')
        email = request_data.get('email')

        if event_type == 'unsubscribed':
            self._handle_unsubscribe(email)
        elif event_type == 'opened':
            self._handle_email_open(email, request_data)
        elif event_type == 'clicked':
            self._handle_email_click(email, request_data)

        return json.dumps({'status': 'success'})

    def _verify_signature(self, secret, payload, signature):
        """Verify the webhook signature using HMAC."""
        computed_signature = hmac.new(
            secret.encode('utf-8'),
            msg=payload,
            digestmod=hashlib.sha256
        ).hexdigest()
        return hmac.compare_digest(computed_signature, signature)

Setting Up Sendinblue Webhooks

After deploying your Odoo webhook controller, configure Sendinblue to send events. Use the Sendinblue API or dashboard to create a new webhook. Point the webhook URL to your Odoo instance’s public endpoint, typically https://your-odoo-domain.com/sendinblue/webhook. Select the specific events you want to receive: hard bounce, soft bounce, unsubscribed, opened, and clicked. Sendinblue will now push engagement data to your Odoo system.

Initial Contact Synchronization

Develop a batch synchronization method to transfer existing Odoo contacts to Sendinblue. This script processes partners in chunks to respect API rate limits. Filter partners to exclude those without email addresses or those who opt out of marketing.

def sync_existing_contacts(self, batch_size=100):
    """Sync existing Odoo contacts to Sendinblue in batches."""
    partner_model = self.env['res.partner']
    domain = [('email', '!=', False), ('active', '=', True)]
    total_partners = partner_model.search_count(domain)

    for offset in range(0, total_partners, batch_size):
        partners = partner_model.search(domain, offset=offset, limit=batch_size)
        for partner in partners:
            attributes = {
                'FIRSTNAME': partner.first_name or '',
                'LASTNAME': partner.last_name or '',
                'SMS': partner.mobile or '',
                'COMPANY': partner.company_id.name or '',
            }
            self.create_contact(partner.email, attributes)
        _logger.info("Synced batch %s-%s", offset, offset + batch_size)

Data Mapping and Transformation

Core Contact Field Mapping

The contact synchronization requires precise field mapping between Odoo partners and Sendinblue contact attributes. Map Odoo’s res.partner fields to Sendinblue’s predefined and custom attributes. This alignment ensures data consistency across both platforms.

Standard mappings include Odoo’s name field to Sendinblue’s NAME attribute. Split the name into FIRSTNAME and LASTNAME for better personalization. Map Odoo’s phone to Sendinblue’s SMS attribute for SMS marketing. Use company_id.name for the COMPANY attribute to track organizational affiliation.

Handling Custom Attributes

Sendinblue supports custom attributes for specialized data points. Create these attributes in your Sendinblue account before synchronization. Map Odoo’s category_id to a custom TAGS attribute in Sendinblue. Transform the many2many relationship into a comma-separated string for Sendinblue compatibility.

def _prepare_contact_attributes(self, partner):
    """Transform Odoo partner data into Sendinblue contact attributes."""
    attributes = {
        'FIRSTNAME': partner.first_name or '',
        'LASTNAME': partner.last_name or '',
        'SMS': partner.mobile or partner.phone or '',
        'COMPANY': partner.company_id.name or '',
    }
    
    # Handle partner tags/categories
    if partner.category_id:
        tag_names = partner.category_id.mapped('name')
        attributes['TAGS'] = ','.join(tag_names)
    
    # Map Odoo country to Sendinblue country attribute
    if partner.country_id:
        attributes['COUNTRY'] = partner.country_id.name
    
    return attributes

Data Type Transformations

Odoo and Sendinblue use different data formats that require transformation. Convert Odoo's many2one and many2many relationships into flat strings or arrays. Handle date formatting differences between the systems, ensuring proper timezone awareness.

Transform Odoo’s date fields like create_date into ISO 8601 format for Sendinblue. Convert boolean fields like opt_out into appropriate Sendinblue subscription status. Process monetary fields by stripping currency symbols and storing pure numeric values.

Address and Geolocation Mapping

Sendinblue accepts structured address data for geographic segmentation. Split Odoo's address fields into Sendinblue's format. Map `street` to `ADDRESS_1`, `street2` to `ADDRESS_2`, and `city` to `CITY`. Use `state_id.name` for `STATE` and `zip` for `POSTAL_CODE`. This structured data enables geographic targeting in your Sendinblue campaigns.

Subscription Status Synchronization

Maintain consistent subscription status across both systems. Map Odoo’s opt_out field to Sendinblue’s unsubscription lists. When a partner opts out in Odoo, add them to Sendinblue’s global exclusion list. Synchronize unsubscription events from Sendinblue back to Odoo by setting the opt_out field to True.

Handle double opt-in processes where applicable. When a contact confirms subscription in Sendinblue, create a new partner in Odoo with opt_out set to False. This bidirectional sync ensures compliance with email marketing regulations across all touchpoints.

Dealing with Data Model Inconsistencies

Odoo’s relational data model conflicts with Sendinblue’s flat contact structure. Flatten Odoo’s many-to-one relationships like company hierarchy into simple text fields. Handle cases where multiple Odoo partners share the same email address, a common scenario in B2B environments.

Implement a conflict resolution strategy for overlapping data. Prioritize Odoo as the master record for contact information, but respect Sendinblue for marketing engagement data. Create merge rules for situations where both systems contain conflicting information for the same contact.

Error Handling and Resilience

Common API Integration Errors

Sendinblue API interactions generate specific HTTP status codes that require structured handling. A 401 Unauthorized error indicates an invalid or expired API key. A 400 Bad Request typically means malformed contact data or invalid attribute names. A 429 Too Many Requests signals you exceeded Sendinblue’s rate limits.

Handle 404 Not Found errors when updating non-existent contacts. Process 402 Payment Required responses that indicate exceeded plan limits. Log the exact error message and context for each failed API call to facilitate debugging and monitoring.

Implementing Retry Mechanisms

Design a robust retry system for transient API failures. Use exponential backoff for subsequent retry attempts. Start with a two-second delay for the first retry, then double the delay for each additional attempt. Cap the maximum retry delay at five minutes to prevent excessive queue buildup.

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=2, min=2, max=300))
def create_contact_with_retry(self, email, attributes):
    """Create contact with retry logic for transient failures."""
    try:
        return self.create_contact(email, attributes)
    except ApiException as e:
        if e.status in [429, 500, 502, 503, 504]:  # Retry on these status codes
            _logger.warning("Retrying Sendinblue API call after failure: %s", e)
            raise  # Re-raise to trigger retry
        else:
            _logger.error("Non-retryable Sendinblue API error: %s", e)
            return False

Webhook Failure Scenarios

Webhook endpoints face multiple failure modes. Network timeouts can interrupt data transmission from Sendinblue to Odoo. Payload validation failures occur with malformed JSON or missing required fields. Signature verification failures indicate potential security threats.

Implement a dead letter queue for webhook events that fail repeated processing. Store these events in an Odoo model for manual review and reprocessing. This approach prevents data loss while maintaining system stability during extended outages.

Data Validation and Sanitization

Validate all data before transmission to Sendinblue. Verify email format using RFC-compliant validation. Sanitize text fields to remove special characters that might break the API. Check string length limits for Sendinblue attribute fields to prevent truncation.

Validate webhook payloads for required fields and data types. Verify that the event field contains a recognized event type. Ensure the email field exists and passes basic format validation before processing the webhook event.

Monitoring and Alerting

Establish comprehensive monitoring for integration health. Track key metrics like API success rates, webhook processing times, and queue lengths. Set up alerts for sustained API failure rates above five percent. Monitor for webhook response times exceeding thirty seconds, which may indicate system degradation.

Create dashboard visualizations that show synchronization status in real-time. Display the number of pending synchronizations, recent failures, and system throughput. These monitoring capabilities provide operational visibility and enable proactive issue resolution.

Testing and Validation

Development Environment Testing

Begin testing in a isolated development environment that mirrors your production setup. Create test Odoo partners with varied data scenarios: partners with missing email addresses, partners with international phone numbers, partners with special characters in their names. Verify that each test case processes correctly through the integration pipeline.

Test the complete synchronization lifecycle from Odoo to Sendinblue and back. Create a partner in Odoo, trigger synchronization, then verify the contact appears in Sendinblue with correct attribute mapping. Then, simulate a webhook event from Sendinblue and confirm the Odoo partner record updates appropriately.

API Integration Test Suite

Develop a comprehensive test suite that validates all API interactions. Test successful contact creation with complete data. Test contact updates with partial data to ensure proper merge behavior. Test error conditions like duplicate email addresses, invalid attributes, and rate limit exhaustion.

import unittest
from unittest.mock import patch, MagicMock

class TestSendinblueIntegration(unittest.TestCase):

    def setUp(self):
        self.test_partner = self.env['res.partner'].create({
            'name': 'Test Partner',
            'email': 'test@example.com',
            'phone': '+1234567890',
        })

    @patch('sib_api_v3_sdk.ContactsApi.create_contact')
    def test_contact_synchronization_success(self, mock_create):
        """Test successful contact synchronization to Sendinblue."""
        mock_create.return_value = MagicMock()
        
        result = self.env['sendinblue.api'].create_contact(
            self.test_partner.email,
            {'FIRSTNAME': 'Test', 'LASTNAME': 'Partner'}
        )
        
        self.assertTrue(result)
        mock_create.assert_called_once()

    @patch('sib_api_v3_sdk.ContactsApi.create_contact')
    def test_contact_synchronization_failure(self, mock_create):
        """Test contact synchronization failure handling."""
        mock_create.side_effect = ApiException(status=400)
        
        result = self.env['sendinblue.api'].create_contact(
            self.test_partner.email,
            {'FIRSTNAME': 'Test', 'LASTNAME': 'Partner'}
        )
        
        self.assertFalse(result)

Webhook Testing Methodology

Test your webhook endpoint with simulated Sendinblue events. Use tools like Postman or curl to send sample payloads to your webhook URL. Test all event types: email delivered, hard bounce, soft bounce, opened, clicked, unsubscribed, and spam complaint. Verify that each event type updates the correct Odoo partner fields.

Test webhook security by sending requests with invalid signatures. Confirm your endpoint rejects these requests with appropriate error responses. Test payload tampering by modifying field values in valid signed requests to ensure signature verification detects the changes.

Performance and Load Testing

Assess integration performance under realistic load conditions. Simulate synchronizing ten thousand contacts to identify bottlenecks. Measure API response times during peak load and verify they remain within acceptable limits. Test webhook processing capacity by sending high volumes of concurrent events.

Monitor Odoo server resources during synchronization jobs. Check for memory leaks, excessive CPU usage, or database connection exhaustion. Identify the optimal batch size for contact synchronization that maximizes throughput without triggering rate limits.

User Acceptance Testing

Engage business users in the validation process. Have marketing team members verify that synchronized contacts appear correctly in Sendinblue lists. Confirm that engagement data from Sendinblue populates the expected fields in Odoo. Validate that automated workflows trigger based on the integrated data.

Create test scenarios that mirror real business processes. Test a complete customer journey from lead creation in Odoo, through email campaign engagement in Sendinblue, to sales follow-up in Odoo based on that engagement. Verify data consistency at each stage of the process.

Security Considerations

API Key Management

Treat your Sendinblue API key as a sensitive credential deserving protection. Never commit API keys to version control or store them in plaintext within the database. Use Odoo’s ir.config_parameter system with appropriate security flags to encrypt the key at rest.

Implement key rotation policies that mandate regular API key updates. Create a process for immediate key revocation in case of suspected compromise. Use separate API keys for development, testing, and production environments to limit blast radius during security incidents.

Webhook Security Implementation

Webhook endpoints present a significant security surface that requires hardening. Validate the X-Sendinblue-Signature header on every incoming webhook request. Compute the HMAC SHA256 hash of the request payload using your webhook secret and compare it with the provided signature.

Implement replay attack protection by checking event timestamps. Reject webhook requests with timestamps more than five minutes old. This time window balances security with tolerance for reasonable delivery delays in the Sendinblue infrastructure.

Data Privacy and Compliance

Respect data privacy regulations throughout the integration. Map the personal data flowing between systems and document the legal basis for processing. Implement data minimization by synchronizing only necessary fields for marketing operations.

Honor customer consent preferences across both platforms. Synchronize opt-out requests immediately between Odoo and Sendinblue. Implement processes for handling right-to-erasure requests that remove customer data from both systems in a coordinated manner.

Network Security Measures

Encrypt all data in transit between Odoo and Sendinblue. Enforce TLS 1.2 or higher for all API communications. Verify SSL certificates to prevent man-in-the-middle attacks. Configure firewalls to allow outbound connections only to official Sendinblue API endpoints.

Ispute integration components within your network architecture. Place webhook endpoints in a DMZ-like network segment with restricted internal access. Implement network-level rate limiting to prevent denial-of-service attacks on your webhook infrastructure.

Access Control and Audit

Apply principle of least privilege to integration components. Restrict Odoo user permissions so only authorized personnel can configure the Sendinblue integration. Log all synchronization activities and administrative changes for audit purposes.

Monitor for anomalous activities like unexpected large data exports or configuration changes. Set up alerts for multiple failed authentication attempts or unusual API usage patterns that might indicate a security breach.

Performance Optimization

API Rate Limit Management

Sendinblue imposes strict rate limits on API calls that impact integration performance. The standard plan allows three hundred requests per minute. Design your synchronization processes to operate within these constraints while maximizing throughput.

Implement intelligent batching that groups multiple contact operations into efficient batches. Use Sendinblue’s batch contact API endpoints when processing large datasets. Introduce strategic delays between batches to maintain sustainable request rates without triggering throttling.

def sync_contacts_in_batches(self, partner_ids, batch_size=50, delay=1):
    """Sync contacts in batches with configurable delay to respect rate limits."""
    for i in range(0, len(partner_ids), batch_size):
        batch_partner_ids = partner_ids[i:i+batch_size]
        partners = self.env['res.partner'].browse(batch_partner_ids)
        
        for partner in partners:
            self.create_contact_with_retry(partner.email, self._prepare_contact_attributes(partner))
        
        # Respect rate limits with delay between batches
        if i + batch_size < len(partner_ids):
            time.sleep(delay)

Database Query Optimization

Inefficient database queries during synchronization create significant performance bottlenecks. Optimize partner queries by selecting only necessary fields instead of fetching entire records. Use prefetching for related records like company data to avoid N+1 query problems.

Create database indexes on frequently queried fields like email, active, and create_date. These indexes accelerate the partner lookups during both outbound synchronization and webhook processing. Monitor query performance using Odoo’s built-in query logging during load testing.

Caching Strategies

Implement strategic caching to reduce redundant API calls and database queries. Cache Sendinblue list IDs to avoid repeated API calls for list management. Cache transformation rules and field mappings to eliminate redundant computation during contact processing.

Use Odoo’s ORM cache effectively by structuring code to leverage built-in caching. Avoid clearing the cache during synchronization operations unless absolutely necessary. This approach maintains performance across multiple synchronization batches.

Background Job Processing

Move synchronization tasks to background jobs to prevent blocking user interactions. Use Odoo’s queue job system to process contact updates asynchronously. This approach decouples the synchronization workload from the main application threads, maintaining system responsiveness.

Prioritize job queues based on business importance. Process real-time events like new lead creation in high-priority queues. Handle bulk historical synchronizations in lower-priority queues that can tolerate longer processing times.

Monitoring and Capacity Planning

Implement comprehensive performance monitoring to identify optimization opportunities. Track metrics like synchronization throughput, API response times, and queue lengths. Set up alerts for performance degradation so you can address issues before they impact users.

Use monitoring data for capacity planning. Analyze growth trends in contact volume and API usage to forecast future resource requirements. Scale your infrastructure proactively to maintain performance as your contact database expands.