> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.propexo.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.propexo.com/_mcp/server.

# Query Realtime Appointment Availability: Rentcafe

POST https://api.propexo.com/crm/v1/appointment-availability/rentcafe/
Content-Type: application/json

Query Realtime Appointment Availability. If no data has changed since your last request, you will receive a 304 response from RentCafe. To observe changes, please implement data caching on your side.

Reference: https://docs.propexo.com/api-reference/rent-cafe/appointments/query-realtime-appointment-availability-rentcafe

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Servers

- `https://api.propexo.com` (Production, default)
- `https://api.sandbox.propexo.com` (Sandbox)

## Request

### Body (application/json)

This endpoint expects a _crm_v1_appointment-availability_rentcafe__post_input.

- `integration_id` (string, required) — The Propexo unique identifier for the integration
- `community_id` (string, required) — The Propexo unique identifier for the community
- `days_to_query` (integer, optional, default: 2) — The number of days (including the start_date) to query appointment availability for. Defaults to 2 days. Properties can configure a max that may be lower than what you request. In this case, the max for the property will be used.

## Response

### 200

Successful response

- `meta` (CrmV1AppointmentAvailabilityRentcafePostOutputMeta, required)
- `result` (list of CrmV1AppointmentAvailabilityRentcafePostOutputResultItems, required)

## Errors

### 400 Bad Request Error

Bad Request

- `error` (ErrorResponseError, required)

## Types

### CrmV1AppointmentAvailabilityRentcafePostOutputMeta

- `job_id` (string, required)

### CrmV1AppointmentAvailabilityRentcafePostOutputResultItems

- `last_seen` (string, required) — The date the record was last seen from the PMS
- `calendar_type` (enum, required) — The type of calendar
  - Allowed values: `AGENT_CALENDAR`, `PROPERTY_CALENDAR`, `ENTRATA_SELF_GUIDED_TOUR_CALENDAR`
- `x_agent_id` (string, required, nullable) — The external ID of the agent from the integration vendor
- `agent_first_name` (string, required, nullable) — The first name associated with the employee
- `agent_last_name` (string, required, nullable) — The last name associated with the employee
- `default_appointment_length` (double, required, nullable) — A default duration for an appointment on this calendar, in minutes
- `minimum_appointment_lead_time` (double, required, nullable) — The minimum lead time before which you can book an appointment on this calendar, in minutes
- `timezone` (string, required, nullable) — The timezone of the calendar, if such metadata is available. Please contact Propexo Support if you are working with properties outside of the United States and Canada as there may be options for populating this field depending on your business case and integration vendor.
- `calendar_days` (list of CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItems, required)
- `x_community_id` (string, required, nullable) — The external ID of the community from the integration vendor

### ErrorResponseError

- `code` (string, required)
- `message` (string, required)
- `details` (map from string to any, optional)

### CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItems

- `date` (CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItemsDate, required) — Date of the availability
- `day_of_week` (string, required) — Day of the week
- `opening_time` (string, required, nullable) — The routine opening time for when the first appointment can be booked into this calendar
- `closing_time` (string, required, nullable) — The routine closing time for when the last appointment must complete when being booked into this calendar
- `simultaneous_appointment_mode` (enum, required) — What kind of simultaneous or double booked appointments are allowed on this calendar
  - Allowed values: `SINGLE`, `MULTIPLE`, `UNLIMITED`, `UNKNOWN`
- `max_simultaneous_appointments` (double, required, nullable) — The maximum number of simultaneous appointments allowed at the same moment in time on this calendar
- `available_slots` (list of CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItemsAvailableSlotsItems, required)

### CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItemsDate

Date of the availability

### CrmV1AppointmentAvailabilityRentcafePostOutputResultItemsCalendarDaysItemsAvailableSlotsItems

- `start` (string, required) — The start time of the slot
- `end` (string, required, nullable) — The end time of the slot which may not be available in all cases

## Examples

**Request**

```json
{
  "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e",
  "community_id": "comm_1234567890abcdef"
}
```

**Response**

```json
{
  "meta": {
    "job_id": "job_20240615_abcdef123456"
  },
  "result": [
    {
      "last_seen": "2024-06-14T18:45:00Z",
      "calendar_type": "AGENT_CALENDAR",
      "x_agent_id": "agent_9876543210fedcba",
      "agent_first_name": "Emily",
      "agent_last_name": "Johnson",
      "default_appointment_length": 30,
      "minimum_appointment_lead_time": 60,
      "timezone": "America/New_York",
      "calendar_days": [
        {
          "date": "2024-06-15",
          "day_of_week": "Saturday",
          "opening_time": "09:00:00",
          "closing_time": "17:00:00",
          "simultaneous_appointment_mode": "SINGLE",
          "max_simultaneous_appointments": 1,
          "available_slots": [
            {
              "start": "09:00:00",
              "end": "09:30:00"
            },
            {
              "start": "10:00:00",
              "end": "10:30:00"
            },
            {
              "start": "14:00:00",
              "end": "14:30:00"
            }
          ]
        },
        {
          "date": "2024-06-16",
          "day_of_week": "Sunday",
          "opening_time": "10:00:00",
          "closing_time": "16:00:00",
          "simultaneous_appointment_mode": "SINGLE",
          "max_simultaneous_appointments": 1,
          "available_slots": [
            {
              "start": "10:00:00",
              "end": "10:30:00"
            },
            {
              "start": "11:30:00",
              "end": "12:00:00"
            }
          ]
        }
      ],
      "x_community_id": "comm_1234567890abcdef"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.propexo.com/crm/v1/appointment-availability/rentcafe/"

payload = {
    "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e",
    "community_id": "comm_1234567890abcdef"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.propexo.com/crm/v1/appointment-availability/rentcafe/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"integration_id":"intg_9f8b7c6d5e4a3b2c1d0e","community_id":"comm_1234567890abcdef"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.propexo.com/crm/v1/appointment-availability/rentcafe/"

	payload := strings.NewReader("{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\",\n  \"community_id\": \"comm_1234567890abcdef\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.propexo.com/crm/v1/appointment-availability/rentcafe/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\",\n  \"community_id\": \"comm_1234567890abcdef\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.propexo.com/crm/v1/appointment-availability/rentcafe/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\",\n  \"community_id\": \"comm_1234567890abcdef\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.propexo.com/crm/v1/appointment-availability/rentcafe/', [
  'body' => '{
  "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e",
  "community_id": "comm_1234567890abcdef"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.propexo.com/crm/v1/appointment-availability/rentcafe/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\",\n  \"community_id\": \"comm_1234567890abcdef\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e",
  "community_id": "comm_1234567890abcdef"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.propexo.com/crm/v1/appointment-availability/rentcafe/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```