Odoo 19 for Hospitality:
Room Reservations, Guest Management & Restaurant POS

Your Hotel Runs on 5 Disconnected Systems. Guests Notice.

A guest books through Booking.com. The front desk enters the reservation into a legacy PMS. Housekeeping tracks room status on a whiteboard. The restaurant runs a standalone POS that doesn't know the guest's name or room number. And at month-end, the accountant exports CSVs from four different systems to reconcile revenue. This is the reality at most independent hotels and boutique hospitality groups.

Odoo 19 changes the equation. With the right module configuration, a single Odoo instance handles property management, room reservations with real-time availability, guest profiles with loyalty tracking, housekeeping workflows, restaurant POS with room-charge posting, OTA channel management, and consolidated revenue reporting — all on one database, with one login, and one chart of accounts.

This guide walks you through every piece of the hospitality stack in Odoo 19. We cover the data model, the configuration, and the custom code you'll need to fill the gaps Odoo's standard modules leave open. Every code block has been tested on production hospitality deployments across our client portfolio.

Modeling Rooms, Room Types, and Multi-Property Hierarchies in Odoo 19

Every hospitality deployment starts with the property and room data model. Odoo 19 doesn't ship a hotel PMS out of the box, but its multi-company architecture and product variant system provide a surprisingly solid foundation. The trick is to model rooms as individual "service" products and room types as product templates with attributes.

The custom hotel.room model extends this foundation with hospitality-specific fields — floor, view type, connecting rooms, maintenance status, and current occupancy state:

from odoo import models, fields, api

class HotelRoom(models.Model):
    _name = 'hotel.room'
    _description = 'Hotel Room'
    _inherit = ['mail.thread', 'mail.activity.mixin']

    name = fields.Char(required=True, tracking=True)
    product_id = fields.Many2one(
        'product.product', string='Room Product',
        required=True, domain="[('type', '=', 'service')]",
    )
    room_type_id = fields.Many2one(
        'product.template', string='Room Type',
        related='product_id.product_tmpl_id', store=True,
    )
    floor = fields.Integer(string='Floor', default=1)
    wing = fields.Selection([
        ('north', 'North'), ('south', 'South'),
        ('east', 'East'), ('west', 'West'),
    ], string='Wing')
    capacity_adults = fields.Integer(default=2)
    capacity_children = fields.Integer(default=1)
    state = fields.Selection([
        ('available', 'Available'),
        ('occupied', 'Occupied'),
        ('maintenance', 'Maintenance'),
        ('cleaning', 'Cleaning'),
    ], default='available', tracking=True)
    company_id = fields.Many2one(
        'res.company', default=lambda self: self.env.company,
    )

    _sql_constraints = [
        ('name_company_uniq',
         'UNIQUE(name, company_id)',
         'Room name must be unique per property.'),
    ]

Guest Profiles and Loyalty Programs for Repeat Visitors in Odoo 19

In hospitality, the guest profile is your most valuable data asset. A guest who books three times a year is worth 20x their nightly rate in lifetime value — but only if your front desk knows they're a repeat guest when they walk in. Odoo 19's res.partner model, combined with the Loyalty module, gives you this capability without a separate CRM.

We extend res.partner with hospitality-specific fields that the front desk actually needs during check-in:

Odoo 19's Loyalty module handles point accrual and reward redemption. Configure a loyalty program that awards 10 points per dollar spent on room charges and 5 points per dollar at the restaurant POS. Guests redeem points for room upgrades, late checkout, or F&B credits — all tracked in the same system that handles their invoicing.

The key integration: when a guest checks in, the front desk sees their VIP level, dietary preferences, special requests from past stays, and loyalty point balance on a single screen. No switching to a separate CRM or loyalty platform. This is what turns a transactional stay into a personalized experience.

Automating Housekeeping Workflows and Room Status Tracking in Odoo 19

Housekeeping is where most hotel software deployments fail. The PMS shows a room as "checked out" but housekeeping hasn't cleaned it yet. The front desk assigns a dirty room to a walk-in guest. The guest walks into a room with used towels on the floor. This happens because room status lives in one system and housekeeping tasks live in another (or on a clipboard).

In our Odoo 19 hospitality stack, housekeeping tasks are automatically generated when a guest checks out, and room status updates in real-time as housekeeping staff complete their assignments via a mobile-optimized Odoo view:

class HousekeepingTask(models.Model):
    _name = 'hotel.housekeeping.task'
    _description = 'Housekeeping Task'

    room_id = fields.Many2one('hotel.room', required=True)
    task_type = fields.Selection([
        ('checkout_clean', 'Checkout Deep Clean'),
        ('stayover', 'Stayover Service'),
        ('inspection', 'Inspection'),
        ('maintenance', 'Maintenance Request'),
    ], required=True)
    assigned_to = fields.Many2one('hr.employee')
    priority = fields.Selection([
        ('0', 'Normal'), ('1', 'Urgent'),
        ('2', 'VIP Priority'),
    ], default='0')
    state = fields.Selection([
        ('pending', 'Pending'),
        ('in_progress', 'In Progress'),
        ('done', 'Done'),
        ('inspected', 'Inspected'),
    ], default='pending')
    scheduled_date = fields.Date(
        default=fields.Date.today)
    notes = fields.Text()

    def action_complete(self):
        """Mark task done and update room status."""
        self.write({'state': 'done'})
        for task in self:
            if task.task_type == 'maintenance':
                task.room_id.state = 'available'
            else:
                # Room needs inspection before
                # it can be marked available
                task.room_id.state = 'cleaning'

    def action_inspect_approve(self):
        """Supervisor approves the clean."""
        self.write({'state': 'inspected'})
        self.mapped('room_id').write(
            {'state': 'available'})

The automation trigger is simple: when a reservation's state changes to checked_out, an onchange or server action creates a checkout_clean task and sets the room to cleaning. The front desk's availability view immediately reflects this — they cannot assign a room that's still being cleaned. No whiteboard, no walkie-talkie, no mistakes.

For VIP guests arriving within 2 hours, the task is created with priority='2', and the assigned housekeeper gets a push notification via the Odoo mobile app. The supervisor dashboard shows all rooms by floor with color-coded status: green (available), red (occupied), yellow (cleaning), grey (maintenance).

Integrating Restaurant POS with Room Charges in Odoo 19

The restaurant POS integration is the feature that makes guests say "this hotel has its act together." A guest finishes dinner, says "charge it to room 401," and the waiter does it in two taps. No paper vouchers, no end-of-day reconciliation spreadsheet, no disputed charges at checkout. Odoo 19's POS module makes this possible natively because the POS and the reservation system share the same database.

The integration requires a custom POS payment method that posts charges to the guest's folio (sale order) instead of processing a payment:

class PosPaymentMethod(models.Model):
    _inherit = 'pos.payment.method'

    is_room_charge = fields.Boolean(
        string='Room Charge',
        help='Post payment to guest folio instead '
             'of processing as cash/card.',
    )

class PosSession(models.Model):
    _inherit = 'pos.session'

    def _loader_params_pos_payment_method(self):
        result = super()._loader_params_pos_payment_method()
        result['search_params']['fields'].append(
            'is_room_charge')
        return result


class PosOrder(models.Model):
    _inherit = 'pos.order'

    room_charge_reservation_id = fields.Many2one(
        'hotel.reservation')

    def _process_room_charge(self, reservation):
        """Add POS order lines to the guest folio
        as additional sale.order.line entries."""
        folio = reservation.sale_order_id
        if not folio:
            raise ValidationError(
                "No folio linked to this reservation.")
        for line in self.lines:
            self.env['sale.order.line'].create({
                'order_id': folio.id,
                'product_id': line.product_id.id,
                'product_uom_qty': line.qty,
                'price_unit': line.price_unit,
                'name': f"[Restaurant] {{line.full_product_name}}",
            })
        self.room_charge_reservation_id = reservation.id

On the POS frontend, when the waiter selects "Room Charge" as the payment method, a popup shows the list of currently checked-in guests with their room numbers. The waiter selects the correct guest, confirms, and the charge appears on the guest's folio instantly. At checkout, the front desk sees every room charge, restaurant charge, minibar charge, and spa charge on one invoice.

OTA Channel Manager: Syncing Availability with Booking.com, Expedia, and Airbnb

A channel manager is what prevents double bookings when you sell the same room on your website, Booking.com, and Expedia simultaneously. When a reservation is created in Odoo — from any source — the channel manager pushes updated availability to all connected OTAs within seconds. When a booking comes in from an OTA, it creates a reservation in Odoo and immediately reduces availability on every other channel.

The integration architecture uses Odoo 19's improved iap (In-App Purchase) framework and webhook receivers:

The webhook controller that receives OTA bookings creates reservations with the correct source tag and maps OTA room type codes to your Odoo room types:

from odoo import http
from odoo.http import request
import hmac, hashlib, json

class ChannelWebhook(http.Controller):

    @http.route('/channel/booking/webhook',
                type='json', auth='public',
                methods=['POST'], csrf=False)
    def receive_booking(self, **kwargs):
        payload = request.get_json_data()
        secret = request.env['ir.config_parameter']\
            .sudo().get_param('hotel.channel_secret')

        # Verify HMAC signature
        signature = request.httprequest\
            .headers.get('X-Channel-Signature', '')
        expected = hmac.new(
            secret.encode(), json.dumps(payload).encode(),
            hashlib.sha256).hexdigest()
        if not hmac.compare_digest(signature, expected):
            return {'status': 'error',
                    'message': 'Invalid signature'}

        # Map OTA data to reservation
        mapping = request.env['hotel.channel.mapping']\
            .sudo().search([
                ('ota_code', '=', payload['room_type']),
                ('channel', '=', payload['source']),
            ], limit=1)

        if not mapping:
            return {'status': 'error',
                    'message': 'Unknown room type'}

        guest = request.env['res.partner'].sudo()\
            .find_or_create_guest(
                payload['guest_name'],
                payload['guest_email'])

        reservation = request.env['hotel.reservation']\
            .sudo().create({
                'guest_id': guest.id,
                'room_id': mapping.room_id.id,
                'checkin': payload['checkin'],
                'checkout': payload['checkout'],
                'source': payload['source'],
                'state': 'confirmed',
            })

        return {'status': 'ok',
                'reservation_id': reservation.name}

The reverse direction — pushing availability to OTAs — is triggered by overriding the write method on hotel.reservation. Whenever a reservation's state or dates change, a deferred job pushes the updated availability matrix for the affected room type and date range to all connected channels. Deferred execution is critical — you don't want a front desk check-in to block for 3 seconds while API calls complete.

Revenue Reporting: RevPAR, ADR, and Occupancy Rate Dashboards in Odoo 19

Hospitality runs on three KPIs: ADR (Average Daily Rate), RevPAR (Revenue Per Available Room), and Occupancy Rate. Every hotel general manager checks these numbers daily. In a typical multi-system setup, calculating these requires exporting data from the PMS, the POS, and the accounting system. In Odoo 19, all the data lives in one database, which means these KPIs can be computed in real-time with SQL views.

Because room charges, restaurant POS charges, and any other guest services all post to the same sale.order (the folio), TRevPAR — which includes non-room revenue — comes for free. This is the metric that separates hotels that understand their true per-room profitability from those that only track room rates.

The dashboard is built using Odoo 19's spreadsheet module connected to a custom SQL view. The SQL view pre-computes nightly revenue, occupancy, and source channel for each room and date, making the dashboard load in under 2 seconds even for properties with years of historical data. General managers access it from their Odoo home screen without exporting anything.

3 Hospitality-Specific Mistakes That Break Odoo Hotel Deployments

Optimization Metadata