Multilingual Product Descriptions in Odoo for ChannelEngine

When selling products across multiple marketplaces and countries, managing multilingual product content quickly becomes a challenge. Product descriptions, specifications, return policies, and marketing content must be available in the customer's language, and maintaining separate versions manually is time-consuming and difficult to scale.

For businesses using Odoo and ChannelEngine, this becomes even more complex when product listings need to be synchronised across multiple international marketplaces.

This article explains how to dynamically generate multilingual product HTML in Odoo and export it seamlessly to ChannelEngine so each marketplace can display localised product content automatically.

Why Multilingual Product Content Matters

When products are listed on international marketplaces, buyers are more likely to engage with listings presented in their preferred language. Benefits include:

  • Improved customer trust
  • Higher conversion rates
  • Better marketplace ranking
  • Reduced return rates
  • Enhanced brand credibility

By leveraging Odoo's built-in translation framework, you can automatically generate localised HTML content for every supported language.

Challenge of Managing Product Content Across Languages

In a typical Odoo-to-ChannelEngine integration, product data is often stored in a single-language format. This creates challenges when expanding into multiple regions.

Common issues include:

  • Maintaining separate HTML content per language manually
  • Inconsistent translations across marketplaces
  • High operational overhead when adding new regions
  • Lack of scalability for large product catalogues

The goal is to eliminate manual duplication and automate localisation at the source.

Business Requirement

The goal is to:

  • Generate product HTML dynamically for each active language.
  • Include translated product information.
  • Export all language versions to ChannelEngine.
  • Store the generated content in the product's extra data payload.

Each marketplace can then display the appropriate language based on the customer's locale.

Solution Overview

The implementation consists of four major steps:

  • Retrieve all active languages.
  • Generate translated HTML for each language.
  • Store the HTML in a structured dictionary.
  • Include the multilingual HTML in the ChannelEngine export payload.

This approach ensures that product content is generated dynamically at runtime instead of being maintained manually.

Model Configuration

First, create configurable section titles that support translations.

python
class CEHtmlConfig(models.Model):
   _name = 'ce.html.config'
   _description = 'ChannelEngine HTML Configuration'
   specification_title = fields.Char(
       string="Specifications Title",
       translate=True
   )
   returns_title = fields.Char(
       string="Returns Title",
       translate=True
   )

These fields allow administrators to manage localised section headers directly from Odoo.

Fetching Active Languages

Retrieve all installed and active languages from Odoo.

python
languages = self.env['res.lang'].search([
   ('active', '=', True)
])

This ensures the system automatically supports any newly activated language.

Generating HTML for Each Language

Loop through each language and render the QWeb template using the appropriate language context.

multilingual_html = {}

python
for lang in languages:
   html = self.with_context(
       lang=lang.code
   )._render_channelengine_html()
   multilingual_html[lang.code] = html

The with_context() method ensures all translated fields are rendered correctly.

Rendering the QWeb Template

Create a reusable method to generate HTML.

python
def _render_channelengine_html(self):
   template = self.env.ref(
       'your_module.channelengine_product_template'
   )
   return self.env['ir.qweb']._render(
       template.id,
       {'product': self},
       minimal_qcontext=True
   )

This method returns fully rendered HTML for the current language.

Example QWeb Template
xml (QWeb Template)
<t t-name="your_module.channelengine_product_template">
   <div class="product-description">
       <h2 t-esc="product.name"/>
       <p t-field="product.description_sale"/>
       <h3 t-esc="env['ce.html.config'].search([], limit=1).specification_title"/>
       <table>
           <tr t-foreach="product.attribute_line_ids" t-as="line">
               <td t-esc="line.attribute_id.name"/>
               <td t-esc="', '.join(line.value_ids.mapped('name'))"/>
           </tr>
       </table>
       <h3 t-esc="env['ce.html.config'].search([], limit=1).returns_title"/>
   </div>
</t>

All translatable fields automatically adapt to the active language.

Preparing ChannelEngine Payload

Include the generated HTML in the export data.

json (ChannelEngine payload)
extra_data = {
   'ProductHtml': multilingual_html
}
Example output:
{
   "ProductHtml": {
       "en_GB": "<div>...</div>",
       "de_DE": "<div>...</div>",
       "fr_FR": "<div>...</div>",
       "nl_NL": "<div>...</div>"
   }
}

This allows ChannelEngine to dynamically select the correct language version per marketplace.

Sending Data to ChannelEngine

When exporting the product, attach the multilingual HTML.

python (payload update)
payload.update({
   'ExtraData': extra_data
})

ChannelEngine can then consume and distribute the correct localised content to connected marketplaces.

Key Advantages

  • Eliminates the manual work of maintaining multilingual product content
  • Enables faster expansion into new international markets
  • Ensures consistent product messaging across all marketplaces
  • Reduces operational overhead for content management teams
  • Scales seamlessly with growing product catalogues and languages

Best Practices

  • Use translatable fields for all static labels.
  • Keep QWeb templates modular and reusable.
  • Test each language thoroughly.
  • Sanitise HTML before external transmission.
  • Cache rendered content when exporting large catalogues.

Final Thoughts

Integrating multilingual product HTML between Odoo and ChannelEngine creates a powerful foundation for international marketplace expansion. By combining Odoo's translation engine with dynamic QWeb rendering, businesses can automatically deliver localised, professional, and marketplace-ready product content.

This approach not only simplifies operations but also significantly enhances the shopping experience for global customers.

If you're building marketplace integrations with Odoo, multilingual HTML generation should absolutely be part of your export strategy.

Found this article useful?

Explore more development guides and solutions from our team.

Check out more posts

Share

تسجيل الدخول حتى تترك تعليقاً
Building a Brokerbin CSV Export Automation in Odoo