Is API access included in every plan?

Yes. There are no locked tiers or paid API add-ons. Every Areca property can use the REST API, webhooks, and MCP server from day one.

Is there an OpenAPI specification?

Yes. The full OpenAPI reference is published at api.arecabooking.com, with an interactive Swagger UI you can use to explore and try every endpoint.

How are webhooks secured?

Every webhook payload is signed with an HMAC-SHA256 signature using a secret unique to your endpoint. Verify the signature before processing the event to make sure it came from Areca.

What is the Areca MCP server?

It is a Model Context Protocol server that exposes Areca to AI agents such as Claude. Agents can query availability, read folios, and manage reservations, limited to the permission scopes of the token you give them.

Developers

The open hospitality platform
for developers

Build custom integrations, automate front-desk workflows, and deploy AI agents with Areca's REST API, real-time webhooks, and native MCP server.

Explore the API reference Talk to our team

Quickstart

Live room availability
in five lines of code

One bearer token, one request, predictable JSON. Fetch availability and rates per room type for any date range, then create the reservation with a single POST to the same resource.

See every endpoint in the OpenAPI reference

curl "https://api.arecabooking.com/properties/$PROPERTY_ID/availability?startDate=2026-10-01&days=7" \
  -H "Authorization: Bearer $ARECA_API_KEY"

GET /properties/{propertyId}/availability

The platform

Three ways to build on Areca

Request data when you need it, get notified the moment it changes, or hand it to an AI agent. All three share the same permissions and the same source of truth.

REST API

Open REST endpoints with predictable JSON, bearer token authentication, and transparent rate limits. Complete coverage of reservations, inventory, rates, guests, folios, and housekeeping.

API reference

Real-time webhooks

Event-driven architecture with HMAC-signed payloads. Trigger workflows instantly on events like booking.created, checkin.completed, payment.logged, or room.status_changed.

See a payload

Native MCP server

A built-in Model Context Protocol server lets LLMs and AI workflows inspect property context, manage reservations, and execute actions with granular permission scopes.

How it works

Infrastructure, not just software

Most PMS vendors bolt an API onto a closed product and charge extra for it. Areca was designed the other way around.

API-first, not API-added

The Areca dashboard is built on the very same endpoints you call. If a feature exists in the UI, it exists in the API, with the same data, the same validation, and the same speed.

No paywalls, no lock-in

API access is not an enterprise add-on. Reservations, inventory, rates, guests, and folios are open from day one, on every plan, so your data always stays yours.

Events instead of polling

Webhooks push every change the moment it happens. Keep smart locks, messaging apps, and accounting tools in sync without burning requests on polling loops.

Built for AI agents

A native MCP server lets Claude, custom LLM tools, and internal bots read live availability, look up guest folios, and run check-ins, all within the permissions you grant.

Webhooks

Stop polling. Start reacting.

Subscribe to the events you care about and Areca delivers a signed JSON payload to your endpoint within seconds. Verify the HMAC signature, act on the event, and keep every external system perfectly in sync.

booking.created
booking.modified
booking.cancelled
checkin.completed
checkout.completed
payment.logged
room.status_changed

POST /webhooks/areca
X-Areca-Signature: sha256=9f2c4e...

{
  "type": "checkin.completed",
  "createdAt": "2026-10-01T14:02:11Z",
  "propertyId": "7c1e9a52-...",
  "data": {
    "bookingId": "b4d0f3e1-...",
    "room": "204",
    "checkOut": "2026-10-04"
  }
}

MCP server

Give your AI agents a front desk

Areca speaks the Model Context Protocol natively. Connect Claude, your own LLM tooling, or an internal bot and it can reason over live property data and take real actions, scoped to exactly the permissions you assign to its token.

Works with Claude and any MCP-compatible client
Tools for availability, reservations, guests, and folios
Read and write scopes granted per token, never more

Which double rooms are free next weekend, and at what rate?

search_availability 142 ms

{ "from": "2026-10-09", "nights": 2, "occupancy": 2 }

Three double rooms are free on Fri 9 to Sun 11 October:

201Double Deluxe€128 / night
204Double Standard€112 / night
305Double Sea View€146 / night

Want me to hold room 305 for your guest?

availability:readbookings:writefolios:write

Use cases

What will you
build next?

A webhook and a few lines of code are all it takes to connect Areca to the hardware and tools your property already uses.

Generate a door code the moment a guest checks in and push it via webhook to Yale, Salto, or August lock bridges. Revoke it automatically at checkout.

// Fires the moment the front desk checks a guest in
app.post("/webhooks/areca", async (req, res) => {
  const { type, data } = verifyArecaSignature(req);
  if (type === "checkin.completed") {
    const code = await salto.createAccessCode({
      room: data.room,
      validUntil: data.checkOut,
    });
    await sms.send(data.guest.phone, `Your door code: ${code}`);
  }
  res.sendStatus(200);
});

Build tailor-made mobile apps or lobby hardware that look up reservations, collect guest details, and complete check-in directly through the Areca API.

const api = `https://api.arecabooking.com/properties/${propertyId}`;
const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };

// Guest scans the QR code from their confirmation email
const booking = await fetch(`${api}/bookings/${bookingId}`, { headers })
  .then((res) => res.json());

await fetch(`${api}/bookings/${bookingId}/status`, {
  method: "PATCH",
  headers,
  body: JSON.stringify({ status: "CHECKED_IN" }),
});

Push reservation status changes into WhatsApp, Twilio SMS gateways, or your guest experience platform to send the right message at the right moment.

@app.post("/webhooks/areca")
def on_event(event: dict = Depends(verify_areca_signature)):
    if event["type"] == "booking.created":
        guest = event["data"]["guest"]
        twilio.messages.create(
            to=f"whatsapp:{guest['phone']}",
            from_="whatsapp:+14155238886",
            body=f"Hi {guest['firstName']}, your stay is confirmed!",
        )
    return {"ok": True}

Stream folio line items and payment logs into Xero, QuickBooks, or municipal tourist tax portals. No more month-end CSV exports.

// Every payment recorded in Areca lands in Xero
if (event.type === "payment.logged") {
  const { amount, currency, method, bookingId } = event.data;

  await xero.payments.create({
    reference: `Areca ${bookingId}`,
    amount,
    currencyCode: currency,
    account: method === "CARD" ? "090" : "091",
  });
}

// Fires the moment the front desk checks a guest in
app.post("/webhooks/areca", async (req, res) => {
  const { type, data } = verifyArecaSignature(req);
  if (type === "checkin.completed") {
    const code = await salto.createAccessCode({
      room: data.room,
      validUntil: data.checkOut,
    });
    await sms.send(data.guest.phone, `Your door code: ${code}`);
  }
  res.sendStatus(200);
});

const api = `https://api.arecabooking.com/properties/${propertyId}`;
const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };

// Guest scans the QR code from their confirmation email
const booking = await fetch(`${api}/bookings/${bookingId}`, { headers })
  .then((res) => res.json());

await fetch(`${api}/bookings/${bookingId}/status`, {
  method: "PATCH",
  headers,
  body: JSON.stringify({ status: "CHECKED_IN" }),
});

@app.post("/webhooks/areca")
def on_event(event: dict = Depends(verify_areca_signature)):
    if event["type"] == "booking.created":
        guest = event["data"]["guest"]
        twilio.messages.create(
            to=f"whatsapp:{guest['phone']}",
            from_="whatsapp:+14155238886",
            body=f"Hi {guest['firstName']}, your stay is confirmed!",
        )
    return {"ok": True}

// Every payment recorded in Areca lands in Xero
if (event.type === "payment.logged") {
  const { amount, currency, method, bookingId } = event.data;

  await xero.payments.create({
    reference: `Areca ${bookingId}`,
    amount,
    currencyCode: currency,
    account: method === "CARD" ? "090" : "091",
  });
}

Join Areca

Start building on Areca

Explore the API reference today, or tell us what you are building and we will help you ship it.

Explore the API reference Talk to our team

Launching soon! Join the waitlist for exclusive early-bird pricing.

Developer FAQ

Yes. Areca is API-first: the dashboard itself runs on the public REST API, so reservations, availability, rates, guests, folios, and housekeeping are all available to your integrations.

Live room availability in five lines of code