If you’ve worked with Odoo integrations long enough, you’ve probably experienced one of these situations:
- Writing repetitive XML-RPC boilerplate
- Fighting inconsistent payloads
- Wrapping raw API calls in your own abstractions
- Debugging cryptic RPC errors at 2AM
- Maintaining different integrations across multiple Odoo versions
We ran into the same problems.
So we built two lightweight Python libraries designed to make Odoo integrations cleaner, faster, and far more maintainable for developers.
-
For modern Odoo JSON-2 APIs (v18/v19+):
pyodoo-client GitHub
pyodoo-client PyPI -
For legacy XML-RPC Odoo versions (v17 and below):
pyodoo-rpc-client GitHub
pyodoo-rpc-client PyPI
Both libraries were designed around a simple goal:
Make Odoo integrations feel more like modern Python development and less like wrestling transport layers.
Why Another Odoo Client?
The Odoo ecosystem has always had powerful APIs, but developer experience has often lagged behind modern standards.
Many developers still end up writing raw XML-RPC calls manually or building custom wrappers around existing tools. Even within the Odoo community, developers regularly mention frustrations around older RPC tooling, lack of typing, verbose integrations, and outdated patterns.
As Odoo evolves toward newer JSON-2 APIs and gradually moves away from legacy RPC patterns, integrations are also changing.
We wanted libraries that:
- feel clean and Pythonic
- simplify model interactions
- reduce repetitive code
- support modern workflows
- provide safer debugging behavior
- work naturally with real production integrations
pyodoo-client — Built for Odoo 18/19+ JSON APIs
Modern Odoo versions are moving toward the /json/2 API architecture, and pyodoo-client is built specifically for that future.
Instead of juggling raw payloads and repetitive request logic, you get a cleaner ORM-style experience.
Quick Example
from pyodoo_client import OdooClient
odoo = OdooClient(
url="https://your-company.odoo.com",
db="production",
api_key="YOUR_API_KEY",
)
partners = odoo.model("res.partner").search_read({
"domain": [
["is_company", "=", True]
],
"fields": ["name", "email"]
})
print(partners)
Simple. Predictable. Readable.
What Makes It Useful?
ORM-Like Access
Instead of manually crafting transport requests everywhere:
client.model("sale.order")This keeps integrations closer to how Odoo developers already think.
Context Handling That Doesn’t Hurt
Odoo integrations often become messy when context handling spreads across requests.
pyodoo-client supports:
- default contexts
- layered contexts
- per-call overrides
- with_context() patterns
without turning every integration into nested dictionaries.
Better Error Management
Production integrations should not crash unpredictably because of one malformed response.
The client supports:
- safe fallback behavior
- captured error states
- optional exception raising with debug=True
which makes debugging cleaner during development while keeping production integrations stable.
pyodoo-rpc-client — For Legacy Odoo Systems That Still Matter
Let’s be realistic:
A huge number of production Odoo deployments still run on versions using XML-RPC.
And many businesses are not migrating overnight.
That’s where pyodoo-rpc-client comes in.
It provides a much cleaner interface around Odoo’s older RPC architecture while remaining lightweight and easy to use.
Legacy Doesn’t Have to Mean Ugly
Example
from pyodoo_rpc_client import OdooRpcClient
odoo = OdooRpcClient(
url="https://mycompany.example.com",
db="production",
username="[email protected]",
password="password",
)
partners = odoo.model("res.partner").search_read(
[["customer_rank", ">", 0]],
fields=["name", "email"]
)
print(partners)
No massive XML-RPC boilerplate.
No repetitive execute_kw wrappers.
No transport-layer chaos.
Built Around Real Integration Problems
These libraries were designed from practical integration work:
- ERP integrations
- external APIs
- reporting systems
- automation pipelines
- synchronization services
- customer portals
- AI workflows
- business intelligence tooling
The goal was not to create “yet another wrapper.”
The goal was to reduce friction.
Designed for Modern Python Developers
Both libraries support:
- Python 3.9+
- ORM-style model access
- context management
- clean abstraction layers
- debug/runtime control
- lightweight dependency footprint
And most importantly:
they stay out of your way.
Odoo Integrations Are Evolving
The Odoo ecosystem is moving quickly:
- JSON-2 APIs
- AI integrations
- MCP tooling
- external automation platforms
- modern cloud deployments
- hybrid ERP ecosystems
Developers are increasingly expecting:
- cleaner APIs
- better abstractions
- maintainable integrations
- typed workflows
- scalable tooling
You can already see the broader developer community building modern RPC tooling around these expectations.
The old “just use raw XML-RPC” approach is slowly disappearing.
Which Library Should You Use?
Use pyodoo-client if:
- you’re targeting Odoo 18/19+
- you’re using /json/2
- you want modern API workflows
- you’re building future-proof integrations
Use pyodoo-rpc-client if:
- you support Odoo 17 or below
- you rely on XML-RPC
- you maintain older production deployments
- you need backward compatibility
Installation
Modern JSON Client
pip install pyodoo-client
Legacy RPC Client
pip install pyodoo-rpc-client
Final Thoughts
Good integration tooling matters.
Developers should spend time building business logic — not rewriting transport wrappers for the hundredth time.
Whether you’re integrating modern Odoo JSON APIs or maintaining legacy ERP systems still running XML-RPC, these libraries aim to make the experience cleaner, more maintainable, and more enjoyable.
Explore the projects:
Built by developers who got tired of rewriting the same Odoo integration layer over and over again.