---
title: "Get Hotel Prices"
method: POST
path: "/hotel-search/hotels/{hotel_id}/prices"
tags: ["hotel-search"]
---

# Get Hotel Prices

`POST /hotel-search/hotels/{hotel_id}/prices`

Get hotel room prices — standalone, no session required.

Guests parse leniently here: content resolves real occupancy from the
search session (or strictly validates when sessionless), so the gateway
must not 422 a client-mangled guest config before content can.

## Path parameters

- `hotel_id` integer, required

## Request body

- HotelPricesRequestLenient — Wire form of HotelPricesRequest for client-facing routes. `guests` is optional and parses leniently on purpose: the search session is the source of truth for occupancy, so clients with a hotel_search_session_id should omit guests entirely and let the handler resolve them from the session. A supplied config parses without supplier caps so a client-mangled value (e.g. a checkout overlay that flattened "8 rooms x 4 adults" into one 32-adult room) still reaches the handler — where the session's guests replace it — instead of 422ing at request parsing. Handlers convert to HotelPricesRequest after resolving occupancy; sessionless requests must supply guests that pass strict validation.
  - `check_in` string, date, required
  - `check_out` string, date, required
  - `guests` LenientGuestConfig — Container for LenientGuestRoom; see that model's docstring.
    - `rooms` LenientGuestRoom[], required
      - `adults` integer, required
      - `children` object[]
  - `hotel_search_session_id` string, uuid, nullable
  - `provider` 'etg' | 'webbeds' | 'axel_discount_etg' | 'axel_discount_webbeds' — Hotel pricing provider identifier. Matches the `source` field on HotelObservation / HotelOffer and the `supplier` column on hotel_quotes. Used to filter detail-pricing requests so the FE can ask for a specific provider's offers after the SERP card surfaces which provider won the cheapest-price race.

## Response `200`

Successful Response

- RoomTypeGroup[]
  - `group_id` string, required
  - `display_name` string, required
  - `images` string[]
  - `amenities` string[]
  - `cancellation_options` VariantOption[]
    - `label` string, required
    - `value` string, required
    - `price_diff` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
      - `amount` integer, required
      - `currency` string, required
  - `meal_options` VariantOption[]
    - `label` string, required
    - `value` string, required
    - `price_diff` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
      - `amount` integer, required
      - `currency` string, required
  - `bed_options` VariantOption[]
    - `label` string, required
    - `value` string, required
    - `price_diff` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
      - `amount` integer, required
      - `currency` string, required
  - `offers` RoomOffer[]
    - `payment_requirement` 'pay_now', nullable — Backend-required payment timing. pay_now requires full payment at booking; null preserves ordinary rate rules.
    - `flight_discount` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
      - `amount` integer, required
      - `currency` string, required
    - `quote_id` string, required
    - `provider` string, required
    - `room_name` string, required
    - `display_name` string, nullable — Optional prepared room title for display only; room_name remains supplier truth.
    - `bed_type` string, nullable
    - `bed_count` integer, nullable
    - `bed_configuration` 'king' | 'two_beds', nullable
    - `room_illustration` 'bed-queen' | 'bed-king' | 'beds-two-queen' | 'beds-two-twin', nullable — Optional prepared room illustration matching the supplier bedding. Display only, not a supplier photo or booking fact. Null means no supported, unambiguous layout; clients must not infer an illustration from room names.
    - `breakfast_included` boolean, nullable
    - `meal_plan` string, nullable
    - `is_refundable` boolean, required
    - `free_cancellation_until` string, date-time, nullable
    - `customer_pay_by` string, date-time, nullable
    - `cancellation_penalty_description` string, nullable
    - `cancellation_policy` HotelOfferCancellationPolicy — Dated rate terms preserved separately from customer refund execution. A missing fee is unknown, never zero. Supplier fees exclude any unverified treatment of Axel's margin, credits, or property charges. For paid periods, a final customer charge/refund requires confirmation.
      - `periods` HotelOfferCancellationPeriod[]
        - `starts_at` string, date-time, nullable
        - `ends_at` string, date-time, nullable
        - `supplier_fee` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
          - `amount` integer, required
          - `currency` string, required
        - `cancel_restricted` boolean
      - `time_basis` 'utc' | 'unspecified', required
      - `no_show_supplier_fee` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `is_complete` boolean
    - `cancel_restricted` boolean
    - `amend_restricted` boolean
    - `rooms_available` integer, nullable
    - `rate_identity_json` object, nullable
    - `pricing` OfferPricing, required — Full price breakdown for a single room offer.
      - `nightly_rate` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `member_nightly_rate` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `total_customer_price` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `member_total_customer_price` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `total_due` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `member_total_due` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `total_at_property` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `mandatory_fees` MandatoryFee[]
        - `name` string, required
        - `fee_type` string, nullable
        - `unit_amount` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
          - `amount` integer, required
          - `currency` string, required
        - `pricing_unit` string, nullable
        - `total` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
          - `amount` integer, required
          - `currency` string, required
      - `supplier_taxes` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `exact_public_rate_comparison` ExactPublicRateComparison — Fee-normalized proof for the exact public version of this stay.
        - `source` string, required
        - `public_total` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
          - `amount` integer, required
          - `currency` string, required
        - `customer_total` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
          - `amount` integer, required
          - `currency` string, required
        - `savings_bucket_percent` integer, required
      - `retail_comparison_total` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `retail_comparison_nightly` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `trip_total` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `trip_total_nightly` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `member_trip_total` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `member_trip_total_nightly` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
    - `deposit` OfferDeposit — Card hold required at booking time. Returned from provider per rate.
      - `amount` Money, required — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
        - `amount` integer, required
        - `currency` string, required
      - `is_refundable` boolean
    - `expires_at` string, date-time, nullable
    - `tariff_notes` string, nullable
    - `min_stay_nights` integer, nullable
    - `min_stay_applies_from` string, date, nullable
    - `special_promotions` string[], nullable
    - `minimum_selling_price` Money — Immutable money value stored as integer minor units. Amount is always stored in the smallest currency unit (cents, yen, pesos, etc). This avoids floating-point precision issues and matches payment processor standards. Examples: $19.99 USD -> Money(amount=1999, currency="USD") ¥1000 JPY -> Money(amount=1000, currency="JPY") $1000.00 CLP -> Money(amount=1000, currency="CLP") Serializes to {"amount": 1999, "currency": "USD"}. IMPORTANT: Use Money.from_decimal() for user-facing amounts like "$19.99". The constructor expects integer minor units (cents).
      - `amount` integer, required
      - `currency` string, required
  - `default_quote_id` string, required
  - `beds` string, nullable
  - `sleeps` integer, nullable
  - `description` string, nullable
  - `priced_guests` HotelSearchGuestConfig — Wraps a list of GuestRoom into a typed config object for the discovery API. Reuses the shared GuestRoom model — just adds a container with validation.
    - `rooms` GuestRoomOutput[], required
      - `adults` integer, required — Number of adults
      - `children` object[] — List of children with ages

## Other responses

- `422` — Validation Error

## Changes

> 22 revisions in range; 1 not diffed.

- **2026-09-23** `5d2121d26b96` — 4 info
  - added the optional property `items/offers/items/flight_discount` to the response with the `200` status
  - added the optional property `items/offers/items/payment_requirement` to the response with the `200` status
  - added the optional property `items/offers/items/pricing/exact_public_rate_comparison` to the response with the `200` status
  - added the optional property `items/offers/items/room_illustration` to the response with the `200` status
- **2026-09-22** `b7b1f6448378` — 1 info
  - added the optional property `items/offers/items/bed_count` to the response with the `200` status
- **2026-09-21** `d777249f5e71` — 1 info
  - added the optional property `items/offers/items/display_name` to the response with the `200` status
- **2026-09-19** `e5f778e80f9a` — 1 info
  - added the optional property `items/offers/items/cancellation_policy` to the response with the `200` status

[Change history](https://skmtc.dev/helloaxel/apis/client-api-gateway/changes/hotel-search/hotels/:hotel_id/prices/post.md)

---

[API](https://skmtc.dev/helloaxel/apis/client-api-gateway.md) · [All operations](https://skmtc.dev/helloaxel/apis/client-api-gateway/llms.txt) · [OpenAPI document](https://skmtc.dev/helloaxel/apis/client-api-gateway/revisions/ff95d5d338e4?raw)