> ## Documentation Index
> Fetch the complete documentation index at: https://api-docs.nowbookit.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Availability

> What a venue can offer a party of a given size over a date range.

Ask what a venue can seat, then take the `serviceId`, `sectionId` and option ids straight into [Create a Reservation](/platform/reservation/create-reservation).


## OpenAPI

````yaml platform/reservation/openapi.json GET /venue/{venueId}/availability
openapi: 3.0.4
info:
  title: NowBookIt Reservation API
  description: >-
    REST API for venue availability and reservation lifecycle. Every endpoint is
    venue-scoped: `/api/reservations/venue/{venueId}/...`.
  version: v1
  contact:
    email: platform.integrations@nowbookit.com
servers:
  - url: https://platform.uat.nowbookit.com/api/reservations
    description: UAT
  - url: https://platform.nowbookit.com/api/reservations
    description: Production
security:
  - ApiKeyAuth: []
tags:
  - name: Availability
    description: What a venue can offer for a party size over a date range.
  - name: Reservations
    description: List, read, create, amend and cancel a venue's reservations.
  - name: Reference data
    description: A venue's own guest tags and reservation statuses.
paths:
  /venue/{venueId}/availability:
    get:
      tags:
        - Availability
      summary: Get availability
      description: >-
        Returns one entry per venue calendar day in the requested window, each
        listing the services bookable that day and, per section, the times a
        party of `partySize` can be seated.
      operationId: getAvailability
      parameters:
        - $ref: '#/components/parameters/VenueId'
        - name: startDate
          in: query
          required: true
          description: >-
            Window start. A bare ISO date (`2026-09-01`) means the whole day; a
            full local ISO datetime (`2026-09-01T18:00:00`) means that exact
            time. Venue-local wall clock — do not send a `Z` suffix or an
            offset. A range entirely in the past is rejected with `400`, judged
            against the venue's own calendar date. Where the venue sets a
            minimum notice period, the window simply starts no sooner than that.
          schema:
            type: string
            example: '2026-09-01'
        - name: endDate
          in: query
          required: false
          description: >-
            Window end, inclusive. Same two forms as `startDate`, and the two
            can mix. Defaults to `startDate`, so a bare `startDate` on its own
            returns that whole day. Send the same datetime for both to ask about
            one slot.
          schema:
            type: string
            example: '2026-09-03'
        - name: partySize
          in: query
          required: true
          description: >-
            Number of guests. Integer, at least 1. A party over the venue's
            maximum is rejected with `400`.
          schema:
            type: integer
            minimum: 1
            example: 2
        - name: serviceId
          in: query
          required: false
          description: >-
            Restrict the response to one service **or** event, by id. Every
            dated occurrence of that service in the range is kept.
          schema:
            type: string
            example: service_dinner
        - name: sectionId
          in: query
          required: false
          description: >-
            Restrict each service's `availableSections` to one section. A
            service that does not offer the section is dropped entirely rather
            than returned with an empty section list.
          schema:
            type: string
            example: section_main
        - name: includeDiaryOnlyTables
          in: query
          required: false
          description: >-
            Include tables the venue keeps for its own diary bookings. `true`
            includes them; absent or `false` uses your integration's default.
          schema:
            type: boolean
      responses:
        '200':
          description: One entry per venue calendar day in the window.
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/AvailabilityDay'
              example:
                - venueId: '6247'
                  date: '2026-09-01'
                  isVenueOpen: true
                  availableServices:
                    - serviceId: service_dinner
                      serviceName: Dinner
                      continuesBack: false
                      continuesNext: false
                      isEvent: false
                      description: <p>Three-course set menu with matched wines.</p>
                      policyAgreementRequired: true
                      policyAgreementText: <p>A 48-hour cancellation policy applies.</p>
                      pricing:
                        paymentType: Deposit
                        pricingType: PerPerson
                        price: 2500
                        peopleRequired: 1
                        isPromotion: false
                        singleMenuPerBooking: false
                      menuOptions:
                        - id: menuoption_set_menu
                          name: Set Menu
                          paymentType: Deposit
                          price: 2500
                      menuOptionUpSellItems: []
                      availableSections:
                        - sectionId: section_main
                          sectionName: Main Dining
                          availableTimes:
                            - '18:00:00'
                            - '18:15:00'
                            - '18:30:00'
                            - '18:45:00'
                            - '19:00:00'
        '400':
          $ref: '#/components/responses/ValidationFailed'
        '404':
          $ref: '#/components/responses/NotFound'
        '500':
          $ref: '#/components/responses/ServerError'
components:
  parameters:
    VenueId:
      name: venueId
      in: path
      required: true
      description: The venue being addressed. Every endpoint on this API is venue-scoped.
      schema:
        type: string
        minLength: 1
        example: '6247'
  schemas:
    AvailabilityDay:
      type: object
      description: Availability for one venue calendar day.
      required:
        - venueId
        - date
        - isVenueOpen
        - availableServices
      properties:
        venueId:
          type: string
          description: The venue this day belongs to.
        date:
          type: string
          format: date
          description: The venue's own calendar date, not a UTC one.
        isVenueOpen:
          type: boolean
          description: True when at least one service is bookable on this day.
        availableServices:
          type: array
          items:
            $ref: '#/components/schemas/AvailabilityService'
          description: >-
            The services bookable on this day. Empty when the venue is closed or
            nothing can seat the party.
    AvailabilityService:
      type: object
      required:
        - serviceId
        - serviceName
        - continuesBack
        - continuesNext
        - isEvent
        - policyAgreementRequired
        - availableSections
      properties:
        serviceId:
          type: string
          description: Pass this back as `serviceId` when creating a reservation.
          example: service_dinner
        serviceName:
          type: string
          example: Dinner
          description: >-
            Display name. Always address the service by `serviceId`, not by
            name.
        continuesBack:
          type: boolean
          description: >-
            The service started before this day — the tail of an overnight
            sitting. Each day carries only the slots falling within that
            calendar day, so the two halves never overlap.
        continuesNext:
          type: boolean
          description: >-
            The service runs past this day into the next — the head of an
            overnight sitting.
        isEvent:
          type: boolean
          description: >-
            A dated one-off rather than a recurring sitting. Events are exempt
            from the venue's future-booking horizon.
        description:
          type: string
          description: >-
            Venue-written HTML describing the service or event. Omitted when the
            venue has not written one.
          example: <p>Three-course set menu with matched wines.</p>
        policyAgreementRequired:
          type: boolean
          description: The guest must accept `policyAgreementText` before booking.
        policyAgreementText:
          type: string
          description: >-
            Venue-written HTML policy shown to the guest. Omitted when the venue
            has not written one.
          example: <p>A 48-hour cancellation policy applies.</p>
        pricing:
          allOf:
            - $ref: '#/components/schemas/AvailabilityPricing'
          description: >-
            Omitted entirely when your integration is not granted pricing —
            never present but empty.
        menuOptions:
          type: array
          description: >-
            The main options the guest chooses from. Omitted when your
            integration is not granted booking options; an empty array means the
            service offers none.
          items:
            $ref: '#/components/schemas/AvailabilityMenuOption'
        menuOptionUpSellItems:
          type: array
          description: Optional extras. Same omission rule as `menuOptions`.
          items:
            $ref: '#/components/schemas/AvailabilityMenuOption'
        availableSections:
          type: array
          items:
            $ref: '#/components/schemas/AvailabilitySection'
          description: >-
            The sections that can seat the party, each with its own bookable
            times.
      description: >-
        A service bookable on this day. A service is returned when its bookable
        span overlaps the window, not only when it falls entirely inside it. It
        is left out once the venue's booking cutoff for that sitting has passed,
        when it is beyond how far ahead the venue takes bookings, or when
        `sectionId` was supplied and the service does not offer that section.
    ValidationErrorResponse:
      allOf:
        - $ref: '#/components/schemas/ErrorResponse'
        - type: object
          required:
            - errors
          properties:
            errors:
              type: object
              description: >-
                Field path to the messages for that field. A cross-field rule
                with no single field to blame is keyed `query`, `path` or
                `body`.
              additionalProperties:
                type: array
                items:
                  type: string
    ErrorResponse:
      type: object
      required:
        - code
        - message
        - requestId
      properties:
        code:
          type: string
          description: >-
            The error class, e.g. `ValidationError`, `NotFoundError`,
            `InternalError`.
          example: NotFoundError
        message:
          type: string
        requestId:
          type: string
          description: Quote this when reporting a problem.
    AvailabilityPricing:
      type: object
      description: >-
        The payment terms that apply to this service occurrence for the
        requested party size, including any promotion that applies.
      required:
        - paymentType
        - pricingType
        - price
        - peopleRequired
        - isPromotion
      properties:
        paymentType:
          $ref: '#/components/schemas/PaymentType'
        pricingType:
          $ref: '#/components/schemas/PricingType'
        price:
          type: number
          description: Amount in the venue's currency.
        peopleRequired:
          type: integer
          description: Party size from which this configuration applies.
        isPromotion:
          type: boolean
          description: >-
            True when a promotion or temporary booking option applies rather
            than the service's usual terms.
        promotionCode:
          type: string
        discountAmount:
          type: number
        discountPercentage:
          type: number
        singleMenuPerBooking:
          type: boolean
          description: >-
            The whole party takes one menu — the guest picks exactly one main
            option rather than any combination.
        upSellHeading:
          type: string
        upSellDescription:
          type: string
    AvailabilityMenuOption:
      type: object
      required:
        - id
        - name
        - paymentType
        - price
      properties:
        id:
          type: string
          description: Pass this back as `menuOptionId` when creating a reservation.
          example: menuoption_set_menu
        name:
          type: string
          example: Set Menu
        paymentType:
          $ref: '#/components/schemas/MenuOptionPaymentType'
        price:
          type: number
          description: Per-unit price.
        childOptions:
          type: array
          description: Ids of the extras that may be selected under this option.
          items:
            type: string
    AvailabilitySection:
      type: object
      required:
        - sectionId
        - sectionName
        - availableTimes
      properties:
        sectionId:
          type: string
          description: Pass this back as `sectionId` when creating a reservation.
          example: section_main
        sectionName:
          type: string
          example: Main Dining
        availableTimes:
          type: array
          description: >-
            Bookable start times as `HH:mm:ss` in the venue's timezone. Seconds
            are always present and always `00`; parse the whole string rather
            than assuming `HH:mm`. To book one, join it to this entry's `date`
            and send it as `localBookingDateAndTime` — `2026-09-01T18:30:00`.
          items:
            type: string
            example: '18:30:00'
    PaymentType:
      type: string
      description: How the reservation takes payment, if at all.
      example: Deposit
    PricingType:
      type: string
      description: How the payable amount was arrived at — a label, not a multiplier.
      example: PerPerson
    MenuOptionPaymentType:
      type: string
      description: How a booking option is charged.
      example: Deposit
  responses:
    ValidationFailed:
      description: >-
        The request failed validation. `errors` is keyed by field path —
        `query`, `path` or `body` for an issue with no single field to blame.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ValidationErrorResponse'
          example:
            code: ValidationError
            message: Query parameters failed validation
            requestId: 0f1c9f2e-4b8a-4c1e-9d33-2a7f5b1c8e90
            errors:
              partySize:
                - partySize must be at least 1
              endDate:
                - endDate must be on or after startDate
    NotFound:
      description: >-
        The venue or reservation does not exist, or does not belong to the venue
        addressed.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: NotFoundError
            message: 'Venue not found: 6247'
            requestId: 0f1c9f2e-4b8a-4c1e-9d33-2a7f5b1c8e90
    ServerError:
      description: An unexpected failure. Quote `requestId` when reporting one.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            code: InternalError
            message: Internal server error
            requestId: 0f1c9f2e-4b8a-4c1e-9d33-2a7f5b1c8e90
  securitySchemes:
    ApiKeyAuth:
      type: http
      scheme: bearer
      description: >-
        Your API key. See [Authorization](/platform/authorization) to create
        one.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.