Odoo API एकीकरण: REST, JSON-RPC, और XML-RPC गाइड

ओडू 19 तीन एपीआई इंटरफेस को उजागर करता है जो सरल डेटा पुनर्प्राप्ति से लेकर जटिल वर्कफ़्लो स्वचालन तक सब कुछ कवर करता है। चाहे आप एक कस्टम मोबाइल ऐप बना रहे हों, तीसरे पक्ष के प्लेटफ़ॉर्म के साथ सिंक कर रहे हों, या बाहरी माइक्रोसर्विसेज के साथ ओडू की क्षमताओं का विस्तार कर रहे हों, ओडू एपीआई परत में महारत हासिल करना किसी भी गंभीर एकीकरण परियोजना के लिए मूलभूत है।

यह मार्गदर्शिका REST, JSON-RPC, और XML-RPC एकीकरण के लिए कार्यशील कोड उदाहरण, प्रमाणीकरण प्रवाह और वास्तुशिल्प अनुशंसाएँ प्रदान करती है - Odoo 19 एंटरप्राइज़ में उपलब्ध तीन प्राथमिक इंटरफ़ेस।

मुख्य बातें

• Odoo 19 REST (OpenAPI 3.0), JSON-RPC 2.0 और XML-RPC इंटरफेस प्रदान करता है
• प्रमाणीकरण एपीआई कुंजी (अनुशंसित) या सत्र-आधारित लॉगिन का उपयोग करता है
• JSON-RPC जटिल परिचालनों के लिए सबसे अधिक सुविधा संपन्न इंटरफ़ेस है
• REST API OpenAPI 3.0 विनिर्देश का अनुसरण करता है और मानक HTTP क्रियाओं का समर्थन करता है
• XML-RPC विरासत है लेकिन फिर भी बैकवर्ड संगतता के लिए पूरी तरह से समर्थित है
• रेट लिमिटिंग और एरर हैंडलिंग को क्लाइंट साइड पर लागू किया जाना चाहिए
• ओडू 19 में वेबहुक रिकॉर्ड परिवर्तन पर डेटा को बाहरी सिस्टम में भेजता है
• सभी एपीआई कॉल ओडू के एक्सेस अधिकारों और रिकॉर्ड नियमों का सम्मान करते हैं

---

एपीआई इंटरफ़ेस तुलना

कोड की एक पंक्ति लिखने से पहले, अपने उपयोग के मामले के लिए सही एपीआई इंटरफ़ेस चुनें:

REST का उपयोग कब करें: एक मोबाइल ऐप बनाना, वेबहुक-नेटिव प्लेटफ़ॉर्म (Shopify, Stripe) के साथ एकीकृत करना, या जब आपकी टीम REST सम्मेलनों के साथ अधिक सहज हो।

JSON-RPC का उपयोग कब करें: जटिल Odoo सर्वर-साइड विधियों को निष्पादित करना, डोमेन फ़िल्टर के साथ बड़े डेटासेट को पढ़ना, या जब आपको REST के माध्यम से उजागर न होने वाली विधियों तक पहुंच की आवश्यकता हो।

XML-RPC का उपयोग कब करें: REST उपलब्ध होने से पहले निर्मित मौजूदा एकीकरणों को बनाए रखना, या जब आपके प्लेटफ़ॉर्म में परिपक्व XML-RPC क्लाइंट लाइब्रेरीज़ हों।

---

प्रमाणीकरण

एपीआई कुंजी प्रमाणीकरण (अनुशंसित)

Odoo 19 तीनों इंटरफेस के लिए एपीआई कुंजी प्रमाणीकरण का समर्थन करता है। सेटिंग्स → उपयोगकर्ता → आपका उपयोगकर्ता → एपीआई कुंजी के अंतर्गत एक एपीआई कुंजी उत्पन्न करें।

import requests

ODOO_URL = "https://your-odoo.com"
API_KEY = "your_api_key_here"
DATABASE = "your_database"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

एपीआई कुंजियाँ एक विशिष्ट उपयोगकर्ता तक सीमित होती हैं और उस उपयोगकर्ता के एक्सेस अधिकार प्राप्त करती हैं। एकीकरण खातों के लिए न्यूनतम आवश्यक अनुमतियों के साथ समर्पित सेवा उपयोगकर्ता बनाएं।

सत्र-आधारित प्रमाणीकरण (JSON-RPC / XML-RPC)

JSON-RPC के लिए, सत्र स्थापित करने के बाद /web/dataset/call_kw समापन बिंदु का उपयोग करके प्रमाणित करें:

import requests
import json

session = requests.Session()

# Authenticate
auth_payload = {
    "jsonrpc": "2.0",
    "method": "call",
    "params": {
        "db": "your_database",
        "login": "admin",
        "password": "your_password"
    }
}

response = session.post(
    f"{ODOO_URL}/web/session/authenticate",
    json=auth_payload
)
uid = response.json()['result']['uid']
print(f"Authenticated as UID: {uid}")

XML-RPC के लिए, मानक दो-चरणीय प्रमाणीकरण का उपयोग करें:

import xmlrpc.client

url = "https://your-odoo.com"
db = "your_database"
username = "admin"
password = "your_password"

# Step 1: Get UID
common = xmlrpc.client.ServerProxy(f"{url}/xmlrpc/2/common")
uid = common.authenticate(db, username, password, {})

# Step 2: Use UID for subsequent calls
models = xmlrpc.client.ServerProxy(f"{url}/xmlrpc/2/object")

---

रेस्ट एपीआई: ओपनएपीआई 3.0

Odoo 19 OpenAPI 3.0 विनिर्देशन के साथ एक पूर्ण REST API पेश करता है। https://your-odoo.com/api/docs पर इंटरैक्टिव दस्तावेज़ तक पहुंचें।

लिस्टिंग रिकॉर्ड्स

# GET /api/sale.order — list all sales orders
response = requests.get(
    f"{ODOO_URL}/api/sale.order",
    headers=headers,
    params={
        "domain": '[["state", "=", "sale"]]',
        "fields": '["name", "partner_id", "amount_total", "state"]',
        "limit": 50,
        "offset": 0
    }
)
orders = response.json()

एकल रिकॉर्ड पढ़ना

# GET /api/sale.order/{id}
order_id = 123
response = requests.get(
    f"{ODOO_URL}/api/sale.order/{order_id}",
    headers=headers
)
order = response.json()

रिकार्ड बनाना

# POST /api/sale.order
payload = {
    "partner_id": 42,
    "order_line": [
        {
            "product_id": 7,
            "product_uom_qty": 5,
            "price_unit": 100.0
        }
    ]
}
response = requests.post(
    f"{ODOO_URL}/api/sale.order",
    headers=headers,
    json=payload
)
new_order = response.json()

रिकॉर्ड अपडेट करना

# PATCH /api/sale.order/{id}
response = requests.patch(
    f"{ODOO_URL}/api/sale.order/{order_id}",
    headers=headers,
    json={"note": "Rush order — priority handling required"}
)

एक रिकॉर्ड हटाना

# DELETE /api/sale.order/{id}
response = requests.delete(
    f"{ODOO_URL}/api/sale.order/{order_id}",
    headers=headers
)

---

JSON-RPC इंटरफ़ेस

JSON-RPC पूर्ण Odoo Python API तक पहुंच प्रदान करता है, जिसमें सर्वर-साइड विधियां भी शामिल हैं जो REST के माध्यम से उजागर नहीं होती हैं। प्राथमिक समापन बिंदु /web/dataset/call_kw है।

बुनियादी खोजें और पढ़ें

def call_kw(model, method, args, kwargs=None):
    payload = {
        "jsonrpc": "2.0",
        "method": "call",
        "params": {
            "model": model,
            "method": method,
            "args": args,
            "kwargs": kwargs or {}
        }
    }
    response = session.post(
        f"{ODOO_URL}/web/dataset/call_kw",
        json=payload
    )
    return response.json().get('result')

# Search for confirmed sales orders
order_ids = call_kw(
    "sale.order",
    "search",
    [[["state", "=", "sale"]]],
    {"limit": 100, "order": "date_order desc"}
)

# Read specific fields
orders = call_kw(
    "sale.order",
    "read",
    [order_ids],
    {"fields": ["name", "partner_id", "amount_total", "date_order"]}
)

खोजें पढ़ें (संयुक्त)

orders = call_kw(
    "sale.order",
    "search_read",
    [[["partner_id.country_id.code", "=", "US"]]],
    {
        "fields": ["name", "partner_id", "amount_total"],
        "limit": 50,
        "offset": 0,
        "order": "amount_total desc"
    }
)

रिकॉर्ड बनाना

new_id = call_kw(
    "sale.order",
    "create",
    [{
        "partner_id": 42,
        "order_line": [
            (0, 0, {
                "product_id": 7,
                "product_uom_qty": 10,
                "price_unit": 150.0
            })
        ]
    }]
)

सर्वर-साइड तरीकों को कॉल करना

JSON-RPC ओडू मॉडल पर परिभाषित सभी पायथन विधियों तक पहुंच प्रदान करता है:

# Confirm a sales order (triggers workflow)
call_kw("sale.order", "action_confirm", [[order_id]])

# Validate an inventory transfer
call_kw("stock.picking", "button_validate", [[picking_id]])

# Get the action for a button (useful for understanding what a button does)
action = call_kw("sale.order", "action_quotations_with_onboarding", [[]])

---

एक्सएमएल-आरपीसी इंटरफ़ेस

XML-RPC मूल Odoo API है और पूरी तरह से समर्थित है। इंटरफ़ेस में दो समापन बिंदु होते हैं:

• /xmlrpc/2/common - अप्रमाणित विधियाँ (प्रमाणीकृत, संस्करण)
• /xmlrpc/2/object - सभी मॉडल संचालन (यूआईडी की आवश्यकता है)

import xmlrpc.client

url = "https://your-odoo.com"
db, username, password = "mydb", "admin", "mypassword"

common = xmlrpc.client.ServerProxy(f"{url}/xmlrpc/2/common")
uid = common.authenticate(db, username, password, {})
models = xmlrpc.client.ServerProxy(f"{url}/xmlrpc/2/object")

# Search for products
product_ids = models.execute_kw(
    db, uid, password,
    'product.template', 'search',
    [[['sale_ok', '=', True]]],
    {'limit': 100}
)

# Read product data
products = models.execute_kw(
    db, uid, password,
    'product.template', 'read',
    [product_ids],
    {'fields': ['name', 'list_price', 'categ_id']}
)

# Create a new product
new_product_id = models.execute_kw(
    db, uid, password,
    'product.template', 'create',
    [{
        'name': 'My New Product',
        'list_price': 99.99,
        'type': 'consu'
    }]
)

---

डोमेन फ़िल्टर

Odoo के डोमेन फ़िल्टर सिंटैक्स का उपयोग तीनों API प्रकारों में किया जाता है। कुशल डेटा पुनर्प्राप्ति के लिए डोमेन को समझना आवश्यक है।

# Basic operators: =, !=, >, <, >=, <=, like, ilike, in, not in, child_of
domain = [
    ["state", "in", ["sale", "done"]],      # Confirmed or done orders
    ["amount_total", ">=", 1000],            # Total at least 1000
    ["partner_id.country_id.code", "=", "US"] # US customers (related field)
]

# Logical operators: & (AND, default), | (OR), ! (NOT)
domain = [
    "|",
    ["state", "=", "draft"],
    ["state", "=", "cancel"]
]

# Complex: orders from US or UK customers with total > 5000
domain = [
    "|",
    ["partner_id.country_id.code", "=", "US"],
    ["partner_id.country_id.code", "=", "GB"],
    ["amount_total", ">", 5000]
]

---

वेबहुक और इवेंट-संचालित एकीकरण

Odoo 19 रिकॉर्ड परिवर्तनों द्वारा ट्रिगर किए गए आउटबाउंड वेबहुक का समर्थन करता है। सेटिंग्स → तकनीकी → वेबहुक के अंतर्गत वेबहुक कॉन्फ़िगर करें।

वेबहुक कॉन्फ़िगरेशन:

1. सेटिंग्स → तकनीकी → वेबहुक → क्रिएट पर नेविगेट करें
2. मॉडल सेट करें (जैसे, sale.order)
3. ट्रिगर चुनें: बनाएं, लिखें, अनलिंक करें, या कस्टम विधि
4. अपनी प्राप्त सेवा का एंडपॉइंट यूआरएल दर्ज करें
5. वेबहुक को ट्रिगर करने वाले रिकॉर्ड को फ़िल्टर करने के लिए वैकल्पिक रूप से डोमेन सेट करें
6. पेलोड में शामिल करने के लिए फ़ील्ड कॉन्फ़िगर करें

फ्लास्क सेवा में वेबहुक ईवेंट प्राप्त करना:

from flask import Flask, request, jsonify
import hmac, hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "your_webhook_secret"

@app.route("/odoo-webhook", methods=["POST"])
def handle_webhook():
    # Verify signature
    signature = request.headers.get("X-Odoo-Signature")
    body = request.get_data()
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        body,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(signature, expected):
        return jsonify({"error": "Invalid signature"}), 401

    event = request.json
    model = event.get("model")
    record_id = event.get("id")

    # Process the event
    if model == "sale.order":
        handle_order_event(record_id, event)

    return jsonify({"status": "ok"}), 200

---

त्रुटि प्रबंधन और पुनः प्रयास तर्क

मजबूत एकीकरणों को ओडू एपीआई त्रुटियों को शालीनता से संभालना चाहिए।

import time
import requests
from requests.exceptions import RequestException

def api_call_with_retry(url, payload, headers, max_retries=3, backoff=2):
    for attempt in range(max_retries):
        try:
            response = requests.post(url, json=payload, headers=headers, timeout=30)
            response.raise_for_status()

            data = response.json()
            if "error" in data:
                error = data["error"]
                code = error.get("code", 0)
                message = error.get("data", {}).get("message", "Unknown error")

                # Don't retry validation errors
                if code in [200, 100]:
                    raise ValueError(f"Odoo validation error: {message}")

                raise RuntimeError(f"Odoo API error {code}: {message}")

            return data.get("result")

        except (RequestException, RuntimeError) as e:
            if attempt == max_retries - 1:
                raise
            wait = backoff ** attempt
            print(f"Attempt {attempt + 1} failed: {e}. Retrying in {wait}s...")
            time.sleep(wait)

सामान्य त्रुटि कोड:

---

निष्पादन सर्वोत्तम अभ्यास

बैच संचालन: व्यक्तिगत रिकॉर्ड के लिए एपीआई को कभी भी लूप में कॉल न करें। सूचियों के साथ create_multi और write का उपयोग करें:

# Bad: loop with individual creates
for product in products:
    call_kw("product.template", "create", [product])

# Good: batch create
call_kw("product.template", "create", [products])

फ़ील्ड चयन: सभी फ़ील्ड लाने से बचने के लिए हमेशा fields पैरामीटर निर्दिष्ट करें:

# Good: only fetch needed fields
orders = call_kw(
    "sale.order", "search_read",
    [[["state", "=", "sale"]]],
    {"fields": ["name", "amount_total"], "limit": 1000}
)

पृष्ठांकन: बड़े डेटासेट के लिए, limit और offset का उपयोग करके पृष्ठांकन करें:

def fetch_all_records(model, domain, fields, batch_size=500):
    records = []
    offset = 0
    while True:
        batch = call_kw(
            model, "search_read", [domain],
            {"fields": fields, "limit": batch_size, "offset": offset}
        )
        records.extend(batch)
        if len(batch) < batch_size:
            break
        offset += batch_size
    return records

---

अक्सर पूछे जाने वाले प्रश्न

Odoo 19 में JSON-RPC और REST API के बीच क्या अंतर है?

JSON-RPC सभी सर्वर-साइड विधियों सहित संपूर्ण Odoo Python API तक पहुंच प्रदान करता है, जबकि REST OpenAPI 3.0 सम्मेलनों का अनुसरण करता है और अधिक सीमित लेकिन मानकीकृत इंटरफ़ेस को उजागर करता है। नए एकीकरणों के लिए जहां REST आपके उपयोग के मामले को कवर करता है, REST को उसकी खोज योग्यता के लिए प्राथमिकता दी जाती है। जटिल वर्कफ़्लो स्वचालन या कस्टम पायथन विधियों तक पहुंच के लिए, JSON-RPC का उपयोग करें।

मैं बड़े डेटा निर्यात (100k+ रिकॉर्ड) को कुशलतापूर्वक कैसे प्रबंधित करूं?

search_read और 500-1000 रिकॉर्ड के बैच आकार के साथ पृष्ठांकन का उपयोग करें। बहुत बड़े निर्यात के लिए, एक बार के निष्कर्षण के लिए यूआई के माध्यम से ओडू की निर्यात सुविधा का उपयोग करने पर विचार करें, या वास्तविक समय एपीआई कॉल करने के बजाय ऑफ-पीक घंटों के दौरान टुकड़ों में डेटा संसाधित करने के लिए ओडू के ir.cron मॉडल का उपयोग करके पृष्ठभूमि नौकरियों को शेड्यूल करें।

क्या मैं XML-RPC के लिए उपयोगकर्ता नाम/पासवर्ड के बजाय एपीआई कुंजियों का उपयोग कर सकता हूं?

हाँ। Odoo 13+ में, API कुंजियों को XML-RPC प्रमाणित कॉल में पासवर्ड के रूप में उपयोग किया जा सकता है। अपने उपयोगकर्ता प्रोफ़ाइल से एक एपीआई कुंजी बनाएं और इसे अपने पासवर्ड के स्थान पर उपयोग करें: common.authenticate(db, username, api_key, {})। यह सेवा खातों के लिए अनुशंसित दृष्टिकोण है.

मैं एपीआई के माध्यम से मेनी2मैनी और वन2मैनी रिकॉर्ड कैसे बनाऊं?

Odoo के कमांड टुपल्स का उपयोग करें: (0, 0, vals) एक नया संबंधित रिकॉर्ड बनाता है, (1, id, vals) मौजूदा संबंधित रिकॉर्ड को अपडेट करता है, (2, id, 0) संबंधित रिकॉर्ड को हटाता है, (4, id, 0) मौजूदा रिकॉर्ड को लिंक करता है, (5, 0, 0) सभी संबंधित रिकॉर्ड को अनलिंक करता है। ये कमांड JSON-RPC, XML-RPC और REST पर समान रूप से काम करते हैं।

मैं एपीआई के माध्यम से वर्कफ़्लो कार्रवाई (जैसे किसी ऑर्डर की पुष्टि करना) कैसे ट्रिगर करूं?

मॉडल पर संबंधित विधि को कॉल करें। बिक्री आदेश की पुष्टि के लिए, sale.order पर action_confirm पर कॉल करें। किसी डिलीवरी को सत्यापित करने के लिए, stock.picking पर button_validate पर कॉल करें। ये विधियां ओडू के स्रोत कोड में दिखाई देती हैं और यूआई के डेवलपर मोड में बटन की name विशेषता का निरीक्षण करके इन्हें खोजा जा सकता है।

ओडू एपीआई कॉल पर कौन सी दर सीमा लगाता है?

Odoo एप्लिकेशन स्तर पर मूल रूप से API दर सीमा लागू नहीं करता है। दर सीमित करने को रिवर्स प्रॉक्सी (Nginx) या बुनियादी ढांचे के स्तर पर कॉन्फ़िगर किया जाना चाहिए। बाहरी एकीकरण के लिए एक समझदार डिफ़ॉल्ट प्रति आईपी 60 अनुरोध प्रति मिनट है। उच्च-थ्रूपुट एकीकरण के लिए, एक समर्पित सेवा उपयोगकर्ता के साथ कतार-आधारित दृष्टिकोण का उपयोग करें।

---

अगले चरण

एक विश्वसनीय ओडू एपीआई एकीकरण के निर्माण के लिए कामकाजी कोड उदाहरणों से अधिक की आवश्यकता होती है - यह ओडू के डेटा मॉडल के साथ उचित त्रुटि प्रबंधन, निगरानी, ​​क्रेडेंशियल प्रबंधन और संरेखण की मांग करता है।

ECOSIRE की एकीकरण टीम ने Odoo और Shopify, Amazon, GoHighLevel, Power BI, कस्टम ERPs और मालिकाना सिस्टम सहित दर्जनों प्लेटफार्मों के बीच उत्पादन-ग्रेड कनेक्शन बनाए हैं। हम प्रमाणीकरण वास्तुकला, वेबहुक डिज़ाइन, डेटा परिवर्तन और चल रही निगरानी को संभालते हैं।

अपने ओडू एकीकरण प्रोजेक्ट के बारे में ECOSIRE से बात करें →

चाहे आप एक नया एकीकरण शुरू कर रहे हों या टूटे हुए एकीकरण को ठीक कर रहे हों, हमारे इंजीनियर आपकी आवश्यकताओं की समीक्षा करेंगे और एक समाधान प्रदान करेंगे जो पहले दिन से ही किनारे के मामलों को संभाल लेगा।