Odoo REST API: Praktische Beispiele und Integrations-Tutorial

Laut dem Postman-Bericht „2025 State of APIs“ integrieren 73 % der Unternehmen ihr ERP mittlerweile in mindestens drei externe Systeme. Odoo, das über 12 Millionen Benutzer weltweit unterstützt, stellt sein gesamtes Datenmodell über eine umfangreiche API-Ebene zur Verfügung. Dennoch bereitet die Dokumentation vielen Entwicklern Probleme mit Authentifizierungsabläufen, Batch-Vorgängen und der Fehlerbehandlung auf Produktionsniveau.

Dieses Tutorial bietet zum Kopieren und Einfügen bereite Beispiele in Python und Node.js für jedes gängige Integrationsmuster. Egal, ob Sie Shopify-Bestellungen synchronisieren, Daten aus einer mobilen App übertragen oder ein benutzerdefiniertes Dashboard erstellen, dieser Leitfaden deckt alles ab.

Wichtige Erkenntnisse

• Odoo bietet drei API-Zugriffsmethoden: XML-RPC (Legacy, alle Versionen), JSON-RPC (Web-Client-Protokoll) und REST API (Odoo 17+ mit API-Schlüsseln) – jeweils mit unterschiedlicher Authentifizierung und Anwendungsfällen.
• API-Schlüsselauthentifizierung (Odoo 17+) ist der empfohlene Ansatz für Server-zu-Server-Integrationen – keine Sitzungsverwaltung, keine CSRF-Tokens, einfache HTTP-Header.
• Suchdomänen nutzen die leistungsstarke polnische Notation von Odoo zum Filtern – beherrschen Sie die Operatoren und Sie können jede Datenkombination abfragen.
• Batch-Vorgänge sind für die Leistung von entscheidender Bedeutung – das Erstellen von 1.000 Datensätzen mit einem API-Aufruf ist 50-mal schneller als 1.000 einzelne Aufrufe.
• Fehlerbehandlung und Ratenbegrenzung sind für Produktionsintegrationen unerlässlich – Odoo gibt strukturierte Fehlerantworten zurück, die Ihr Code ordnungsgemäß analysieren und verarbeiten sollte.

1. Authentifizierungsmethoden

Methode 1: API-Schlüssel (empfohlen für Odoo 17+)

API-Schlüssel sind die einfachste und sicherste Methode für die Server-zu-Server-Kommunikation:

# Generate an API key in Odoo:
# Settings → Users → Select user → Account Security → New API Key

# Test authentication
curl -X GET "https://your-odoo.com/api/res.partner" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

Python mit API-Schlüssel:

import requests

class OdooAPI:
    def __init__(self, url, api_key):
        self.url = url.rstrip('/')
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
        })

    def get(self, model, params=None):
        response = self.session.get(
            f'{self.url}/api/{model}',
            params=params or {}
        )
        response.raise_for_status()
        return response.json()

    def post(self, model, data):
        response = self.session.post(
            f'{self.url}/api/{model}',
            json=data
        )
        response.raise_for_status()
        return response.json()

# Usage
odoo = OdooAPI('https://your-odoo.com', 'your-api-key-here')
partners = odoo.get('res.partner', {'limit': 10})

Node.js mit API-Schlüssel:

const axios = require('axios');

class OdooAPI {
  constructor(url, apiKey) {
    this.client = axios.create({
      baseURL: `${url}/api`,
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      timeout: 30000,
    });
  }

  async get(model, params = {}) {
    const { data } = await this.client.get(`/${model}`, { params });
    return data;
  }

  async post(model, body) {
    const { data } = await this.client.post(`/${model}`, body);
    return data;
  }

  async put(model, id, body) {
    const { data } = await this.client.put(`/${model}/${id}`, body);
    return data;
  }

  async delete(model, id) {
    const { data } = await this.client.delete(`/${model}/${id}`);
    return data;
  }
}

// Usage
const odoo = new OdooAPI('https://your-odoo.com', 'your-api-key');
const partners = await odoo.get('res.partner', { limit: 10 });

Methode 2: JSON-RPC (Alle Versionen)

JSON-RPC ist das Protokoll, das der Web-Client von Odoo intern verwendet. Es funktioniert mit allen Odoo-Versionen:

import requests
import json

class OdooJsonRpc:
    def __init__(self, url, db, username, password):
        self.url = url.rstrip('/')
        self.db = db
        self.session = requests.Session()
        self.uid = self._authenticate(username, password)

    def _authenticate(self, username, password):
        response = self._call('/web/session/authenticate', {
            'db': self.db,
            'login': username,
            'password': password,
        })
        if not response.get('uid'):
            raise Exception(f"Authentication failed: {response}")
        return response['uid']

    def _call(self, endpoint, params):
        payload = {
            'jsonrpc': '2.0',
            'method': 'call',
            'params': params,
            'id': None,
        }
        response = self.session.post(
            f'{self.url}{endpoint}',
            json=payload,
            headers={'Content-Type': 'application/json'}
        )
        result = response.json()
        if result.get('error'):
            raise Exception(result['error']['data']['message'])
        return result.get('result')

    def search_read(self, model, domain=None, fields=None, limit=80, offset=0, order=None):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'search_read',
            'args': [domain or []],
            'kwargs': {
                'fields': fields or [],
                'limit': limit,
                'offset': offset,
                'order': order or '',
            },
        })

    def create(self, model, values):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'create',
            'args': [values],
            'kwargs': {},
        })

    def write(self, model, ids, values):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'write',
            'args': [ids, values],
            'kwargs': {},
        })

# Usage
odoo = OdooJsonRpc('https://your-odoo.com', 'mydb', 'admin', 'password')
orders = odoo.search_read('sale.order', [('state', '=', 'sale')],
                          fields=['name', 'amount_total', 'partner_id'],
                          limit=20)

Methode 3: XML-RPC (Legacy, Universal)

import xmlrpc.client

url = 'https://your-odoo.com'
db = 'mydb'
username = 'admin'
password = 'password'

# Authenticate
common = xmlrpc.client.ServerProxy(f'{url}/xmlrpc/2/common')
uid = common.authenticate(db, username, password, {})

# Create models proxy
models = xmlrpc.client.ServerProxy(f'{url}/xmlrpc/2/object')

# Search and read
partners = models.execute_kw(db, uid, password,
    'res.partner', 'search_read',
    [[('is_company', '=', True), ('country_id.code', '=', 'US')]],
    {'fields': ['name', 'email', 'phone'], 'limit': 10}
)

2. CRUD-Operationen

Datensätze erstellen

# Create a single contact
partner_id = odoo.create('res.partner', {
    'name': 'Acme Corporation',
    'is_company': True,
    'email': '[email protected]',
    'phone': '+1-555-0123',
    'street': '123 Main Street',
    'city': 'San Francisco',
    'state_id': 5,  # California
    'country_id': 233,  # United States
    'category_id': [(6, 0, [1, 3])],  # Tags: replace all with IDs 1 and 3
})

# Create a sale order with lines
order_id = odoo.create('sale.order', {
    'partner_id': partner_id,
    'date_order': '2026-03-23',
    'order_line': [
        (0, 0, {
            'product_id': 42,
            'product_uom_qty': 5,
            'price_unit': 99.99,
        }),
        (0, 0, {
            'product_id': 43,
            'product_uom_qty': 2,
            'price_unit': 149.99,
        }),
    ],
})

Node.js-Äquivalent:

// Create a contact
const partnerId = await odoo.post('res.partner', {
  name: 'Acme Corporation',
  is_company: true,
  email: '[email protected]',
  phone: '+1-555-0123',
  street: '123 Main Street',
  city: 'San Francisco',
  country_id: 233,
});

// Create sale order with lines
const orderId = await odoo.post('sale.order', {
  partner_id: partnerId,
  date_order: '2026-03-23',
  order_line: [
    [0, 0, { product_id: 42, product_uom_qty: 5, price_unit: 99.99 }],
    [0, 0, { product_id: 43, product_uom_qty: 2, price_unit: 149.99 }],
  ],
});

Datensätze lesen

# Read specific fields from specific records
data = odoo.search_read('sale.order',
    domain=[('state', '=', 'sale'), ('amount_total', '>', 500)],
    fields=['name', 'partner_id', 'amount_total', 'date_order', 'state'],
    limit=50,
    offset=0,
    order='date_order desc'
)

# Read a single record by ID (REST API)
# GET /api/sale.order/42?fields=name,amount_total

// Node.js — read with pagination
async function fetchAllOrders(odoo) {
  const pageSize = 100;
  let offset = 0;
  let allOrders = [];

  while (true) {
    const orders = await odoo.get('sale.order', {
      domain: JSON.stringify([['state', '=', 'sale']]),
      fields: 'name,partner_id,amount_total',
      limit: pageSize,
      offset,
      order: 'date_order desc',
    });

    allOrders = allOrders.concat(orders);
    if (orders.length < pageSize) break;
    offset += pageSize;
  }

  return allOrders;
}

Datensätze aktualisieren

# Update a single record
odoo.write('res.partner', [partner_id], {
    'phone': '+1-555-9999',
    'website': 'https://acme.com',
})

# Update multiple records at once
draft_orders = odoo.search_read('sale.order',
    [('state', '=', 'draft'), ('date_order', '<', '2026-01-01')],
    fields=['id']
)
ids = [o['id'] for o in draft_orders]
odoo.write('sale.order', ids, {'note': 'Reviewed Q1 2026'})

Datensätze löschen

# Delete records (use with caution)
odoo.write('res.partner', [obsolete_id], {'active': False})  # Prefer archiving

# Actually delete (rarely needed)
# models.execute_kw(db, uid, password, 'res.partner', 'unlink', [[obsolete_id]])

3. Erweiterte Suchdomänen

Die Suchdomänen von Odoo verwenden die polnische Notation (Präfixnotation), um Bedingungen zu kombinieren. Der Standardoperator zwischen Bedingungen ist AND. Verwenden Sie die Pipe '|' für ODER und kaufmännisches Und „&“ für explizites UND. Jedes Blatt ist ein Tupel aus Feldname, Operator und Wert. Odoo unterstützt die Punktnotation, um nach verwandten Modellfeldern zu filtern, z. B. „partner_id.country_id.code“, um Bestellungen nach dem Land des Kunden zu filtern.

# Complex domain examples

# Orders from US customers with amount > $1000, created this year
domain = [
    ('partner_id.country_id.code', '=', 'US'),
    ('amount_total', '>', 1000),
    ('date_order', '>=', '2026-01-01'),
    ('state', 'in', ['sale', 'done']),
]

# OR condition: email contains 'gmail' OR 'yahoo'
domain = [
    '|',
    ('email', 'ilike', 'gmail.com'),
    ('email', 'ilike', 'yahoo.com'),
]

# Complex: (state=sale AND amount>1000) OR (state=done AND amount>5000)
domain = [
    '|',
    '&', ('state', '=', 'sale'), ('amount_total', '>', 1000),
    '&', ('state', '=', 'done'), ('amount_total', '>', 5000),
]

# Negation: NOT archived
domain = [('active', '!=', False)]

# NULL check: has no email
domain = [('email', '=', False)]

# Hierarchical: all child categories of 'Electronics'
domain = [('categ_id', 'child_of', electronics_id)]

# Date ranges
from datetime import datetime, timedelta
domain = [
    ('create_date', '>=', (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')),
    ('create_date', '<', datetime.now().strftime('%Y-%m-%d')),
]

Operator-Referenz

4. Batch-Operationen

Batch-Vorgänge sind für die Leistung von entscheidender Bedeutung. Erstellen Sie niemals Datensätze einzeln in einer Schleife:

# BAD: 1000 API calls (slow, ~300 seconds)
for customer in customers:
    odoo.create('res.partner', customer)

# GOOD: 1 API call with batch (fast, ~3 seconds)
# Using JSON-RPC batch create
partner_ids = odoo._call('/web/dataset/call_kw', {
    'model': 'res.partner',
    'method': 'create',
    'args': [customers],  # Pass list of dicts
    'kwargs': {},
})

// Node.js batch pattern with chunking
async function batchCreate(odoo, model, records, chunkSize = 200) {
  const results = [];

  for (let i = 0; i < records.length; i += chunkSize) {
    const chunk = records.slice(i, i + chunkSize);
    console.log(`Creating ${model} batch ${i / chunkSize + 1}/${Math.ceil(records.length / chunkSize)}`);

    const ids = await odoo.post(model, chunk);
    results.push(...(Array.isArray(ids) ? ids : [ids]));

    // Respect rate limits
    if (i + chunkSize < records.length) {
      await new Promise(resolve => setTimeout(resolve, 500));
    }
  }

  return results;
}

// Usage
const customers = generateCustomerData(); // Array of 5000 objects
const ids = await batchCreate(odoo, 'res.partner', customers);
console.log(`Created ${ids.length} partners`);

5. Fehlerbehandlung

Produktionsintegrationen müssen Fehler ordnungsgemäß behandeln:

import requests
import logging
import time

logger = logging.getLogger(__name__)

class OdooAPIClient:
    MAX_RETRIES = 3
    RETRY_DELAY = 2  # seconds

    def __init__(self, url, api_key):
        self.url = url.rstrip('/')
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
        })

    def _request(self, method, endpoint, **kwargs):
        last_error = None

        for attempt in range(self.MAX_RETRIES):
            try:
                response = self.session.request(
                    method,
                    f'{self.url}{endpoint}',
                    timeout=30,
                    **kwargs
                )

                if response.status_code == 429:
                    retry_after = int(response.headers.get('Retry-After', 60))
                    logger.warning(f"Rate limited. Retrying after {retry_after}s")
                    time.sleep(retry_after)
                    continue

                if response.status_code == 401:
                    raise AuthenticationError("Invalid API key or session expired")

                if response.status_code == 403:
                    raise PermissionError(f"Access denied: {response.text}")

                if response.status_code == 404:
                    raise RecordNotFoundError(f"Record not found: {endpoint}")

                if response.status_code >= 500:
                    logger.error(f"Server error {response.status_code}: {response.text}")
                    if attempt < self.MAX_RETRIES - 1:
                        time.sleep(self.RETRY_DELAY * (attempt + 1))
                        continue
                    raise ServerError(f"Server error after {self.MAX_RETRIES} retries")

                response.raise_for_status()
                return response.json()

            except requests.exceptions.ConnectionError as e:
                last_error = e
                logger.warning(f"Connection error (attempt {attempt + 1}): {e}")
                if attempt < self.MAX_RETRIES - 1:
                    time.sleep(self.RETRY_DELAY * (attempt + 1))

            except requests.exceptions.Timeout as e:
                last_error = e
                logger.warning(f"Request timeout (attempt {attempt + 1}): {e}")
                if attempt < self.MAX_RETRIES - 1:
                    time.sleep(self.RETRY_DELAY * (attempt + 1))

        raise ConnectionError(f"Failed after {self.MAX_RETRIES} attempts: {last_error}")

class AuthenticationError(Exception): pass
class PermissionError(Exception): pass
class RecordNotFoundError(Exception): pass
class ServerError(Exception): pass

// Node.js error handling with axios interceptors
const axios = require('axios');

function createOdooClient(url, apiKey) {
  const client = axios.create({
    baseURL: `${url}/api`,
    headers: { Authorization: `Bearer ${apiKey}` },
    timeout: 30000,
  });

  // Response interceptor for error handling
  client.interceptors.response.use(
    (response) => response,
    async (error) => {
      const { config, response } = error;
      config.__retryCount = config.__retryCount || 0;

      // Rate limiting
      if (response?.status === 429) {
        const retryAfter = parseInt(response.headers['retry-after'] || '60', 10);
        console.warn(`Rate limited. Waiting ${retryAfter}s...`);
        await new Promise((r) => setTimeout(r, retryAfter * 1000));
        return client(config);
      }

      // Retry on server errors (max 3)
      if (response?.status >= 500 && config.__retryCount < 3) {
        config.__retryCount += 1;
        const delay = config.__retryCount * 2000;
        console.warn(`Server error ${response.status}. Retry ${config.__retryCount}/3 in ${delay}ms`);
        await new Promise((r) => setTimeout(r, delay));
        return client(config);
      }

      // Structured error response
      const errorMessage = response?.data?.error?.message
        || response?.data?.message
        || error.message;

      throw new Error(`Odoo API Error [${response?.status}]: ${errorMessage}`);
    }
  );

  return client;
}

6. Integrationsbeispiele aus der Praxis

Bestellsynchronisierung von Shopify zu Odoo

class ShopifyOdooSync:
    def __init__(self, odoo_client, shopify_client):
        self.odoo = odoo_client
        self.shopify = shopify_client

    def sync_order(self, shopify_order):
        # 1. Find or create customer
        partner = self._get_or_create_partner(shopify_order['customer'])

        # 2. Map products
        order_lines = []
        for item in shopify_order['line_items']:
            product_id = self._find_product_by_sku(item['sku'])
            if not product_id:
                logger.warning(f"Product not found for SKU: {item['sku']}")
                continue
            order_lines.append((0, 0, {
                'product_id': product_id,
                'product_uom_qty': item['quantity'],
                'price_unit': float(item['price']),
                'discount': self._calc_discount(item),
            }))

        # 3. Create sale order
        order_id = self.odoo.create('sale.order', {
            'partner_id': partner['id'],
            'client_order_ref': shopify_order['name'],  # Shopify order #
            'order_line': order_lines,
            'note': f"Shopify Order: {shopify_order['id']}",
        })

        # 4. Auto-confirm if paid
        if shopify_order['financial_status'] == 'paid':
            self.odoo._call('/web/dataset/call_kw', {
                'model': 'sale.order',
                'method': 'action_confirm',
                'args': [[order_id]],
                'kwargs': {},
            })

        return order_id

    def _get_or_create_partner(self, customer):
        # Search by email first
        existing = self.odoo.search_read('res.partner',
            [('email', '=', customer['email'])],
            fields=['id', 'name'], limit=1)

        if existing:
            return existing[0]

        return {'id': self.odoo.create('res.partner', {
            'name': f"{customer['first_name']} {customer['last_name']}",
            'email': customer['email'],
            'phone': customer.get('phone'),
        })}

    def _find_product_by_sku(self, sku):
        products = self.odoo.search_read('product.product',
            [('default_code', '=', sku)],
            fields=['id'], limit=1)
        return products[0]['id'] if products else None

Webhook-Empfänger (Flask-Beispiel)

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

app = Flask(__name__)

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

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

    payload = request.json
    event_type = payload.get('event')

    if event_type == 'sale.order.confirmed':
        handle_order_confirmed(payload['data'])
    elif event_type == 'stock.picking.done':
        handle_shipment_complete(payload['data'])

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

7. Leistungstipps

Häufig gestellte Fragen

Was ist der Unterschied zwischen XML-RPC, JSON-RPC und REST API in Odoo?

XML-RPC ist das Legacy-Protokoll, das in allen Odoo-Versionen verfügbar ist – es ist ausführlich, wird aber allgemein unterstützt. JSON-RPC ist das vom Odoo-Webclient verwendete Protokoll und bietet die gleiche Funktionalität mit JSON-Nutzlasten. Die REST-API wurde in Odoo 17 eingeführt und bietet Standard-HTTP-Endpunkten eine API-Schlüsselauthentifizierung und ist damit die einfachste Option für moderne Integrationen. Verwenden Sie für neue Projekte die REST-API, wenn Sie Odoo 17 oder höher verwenden.

Wie gehe ich mit Odoo-API-Ratenbegrenzungen um?

Odoo.sh wendet Tarifbegrenzungen basierend auf Ihrer Tarifstufe an. Wenn Sie eine 429-Antwort erhalten, lesen Sie den Retry-After-Header und warten Sie, bevor Sie es erneut versuchen. Implementieren Sie bei Integrationen mit hohem Volumen einen exponentiellen Backoff, stapeln Sie Ihre Vorgänge, um die Anzahl der API-Aufrufe zu reduzieren, und erwägen Sie die Verwendung der geplanten Aktionen von Odoo für die Massenverarbeitung anstelle von Echtzeit-API-Aufrufen für unkritische Synchronisierungen.

Kann ich benutzerdefinierte Python-Methoden über die API aufrufen?

Ja. Jede öffentliche Methode in einem Odoo-Modell kann über XML-RPC oder JSON-RPC mit „execute_kw“ aufgerufen werden. Für die REST-API müssen Sie einen benutzerdefinierten Controller-Endpunkt mit @http.route erstellen. Methoden, die mit einem Unterstrich beginnen, sind privat und können nicht extern über XML-RPC aufgerufen werden. Validieren Sie immer Eingaben in Ihren benutzerdefinierten Methoden, um Injektionsangriffe zu verhindern.

Wie synchronisiere ich große Datensätze effizient?

Verwenden Sie eine Kombination von Strategien: anfängliche vollständige Synchronisierung mit Batch-Vorgängen und Paginierung (Beschränkung auf 200 Datensätze pro Anfrage), dann inkrementelle Synchronisierungen mit write_date-Filterung, um nur Datensätze abzurufen, die seit der letzten Synchronisierung geändert wurden. Speichern Sie den Zeitstempel der letzten Synchronisierung und verwenden Sie ihn als Domänenfilter. Bei sehr großen Datensätzen mit mehr als 100.000 Datensätzen sollten Sie eine direkte Datenbankreplikation anstelle einer API-Synchronisierung in Betracht ziehen.

Ist die Odoo REST API in der Odoo Community Edition verfügbar?

Die native REST-API mit API-Schlüsselauthentifizierung wurde in Odoo 17 Enterprise eingeführt. Für die Odoo Community können Sie XML-RPC oder JSON-RPC verwenden, die in allen Editionen verfügbar sind, oder Community-Module wie das Rest-Framework von OCA installieren, die RESTful-Endpunkte hinzufügen. Die Integrationsdienste von ECOSIRE unterstützen alle Odoo-Editionen und API-Protokolle.

Wie gehe ich mit den Feldern Many2many und One2many in API-Aufrufen um?

Relationale Felder verwenden spezielle Befehlstupel: (0, 0, Werte) zum Erstellen und Verknüpfen eines neuen Datensatzes, (1, ID, Werte) zum Aktualisieren eines verknüpften Datensatzes, (2, ID, 0) zum Löschen eines verknüpften Datensatzes, (3, ID, 0) zum Aufheben der Verknüpfung ohne Löschen, (4, ID, 0) zum Verknüpfen eines vorhandenen Datensatzes, (5, 0, 0) zum Aufheben der Verknüpfung aller Datensätze und (6, 0, [ids]), um alle Links zu ersetzen. Zum Lesen geben diese Felder standardmäßig Listen mit IDs zurück – verwenden Sie search_read mit dem Feldnamen, um vollständige Daten zu erhalten.

Nächste Schritte

Die API-Integration ist das Rückgrat moderner Geschäftssysteme. Unabhängig davon, ob Sie eine einfache Datensynchronisierung oder eine komplexe plattformübergreifende Orchestrierung erstellen, werden Ihnen die Muster in diesem Leitfaden gute Dienste leisten.

Verwandte Ressourcen:

• Odoo Python-Entwicklungsleitfaden – Tauchen Sie tief in das Python-Backend von Odoo ein – Webhook-Debugging-Leitfaden – Fehlerbehebung bei Webhook-Integrationen
• ECOSIRE Marketplace Connectors – Vorgefertigte Integrationen für wichtige Plattformen

Benötigen Sie Hilfe bei der Odoo API-Integration? Das Integrationsteam von ECOSIRE hat Odoo mit über 50 externen Plattformen verbunden, darunter Shopify, Amazon, Salesforce und benutzerdefinierte ERPs. Von einfachen Datensynchronisierungen bis hin zur bidirektionalen Orchestrierung in Echtzeit erstellen wir skalierbare Integrationen. Kostenlose technische Beratung vereinbaren.