# Availability

Coordinating availability across participants, calendars, and resources is one of the core scheduling challenges any product managing meetings will face. Whether booking an interview, scheduling a healthcare appointment, or connecting a customer with an available expert, understanding everyone's actual availability in real-time is essential.

The Availability API is part of Cronofy's temporal grid — built on top of the Calendar API to surface and coordinate real-time availability across all supported calendar providers.

![](/developers/scheduling/availability_api.8a0f4ad41f5e84484802fb8850907b8f890b1e6735298e473cfac54f67097237.png)
Because the Availability API queries across all calendar providers Cronofy supports, you can check Google and Exchange calendars simultaneously, and check a mix of personal calendars, shared mailboxes and meeting rooms, to find a time that works.

For products building agentic workflows, the same availability infrastructure powers scheduling via the [MCP Server](/developers/mcp-server/index.md), letting AI agents coordinate meetings on behalf of users without manual intervention.

## Anatomy of an Availability query
This example is a query to find a time that works for two required people and one meeting room from a group. In this case we're finding times for a 60 min meeting over the next couple of days.

```json
{
  "participants": [
    {
      "members": [
        { 
          "sub": "acc_5ba21743f408617d1269ea1e",
          "managed_availability": true
         },
        { 
          "sub": "acc_64b17d868090ea21640c914c",
          "managed_availability": true
        }
      ],
      "required": "all"
    },
    {
      "members": [
        { "sub": "res_5ba21743f408617d12693521" },
        { "sub": "res_5ba21743f4000563a26934ea" },
        { "sub": "res_64b17d868090ea21640ad6e0" }
      ],
      "required": 1
    }
  ],
  "required_duration": { "minutes": 60 },
  "query_periods": [
    {
      "start": "2026-09-09T09:00:00Z",
      "end": "2026-09-09T18:00:00Z"
    },
    {
      "start": "2026-09-10T09:00:00Z",
      "end": "2026-09-10T18:00:00Z"
    }
  ],
  "response_format": "slots"
}
```

### Participants
This is an array of objects describing the rules to use in order to find available times for groups of people and/or resources. Each group describes the list of people to consider and how many need to be available.

The `members` attribute of each group, describes the the accounts and/or resources identified by the `sub` value in each member. You will receive this value when you obtain an authorization for a user's or a resource's calendars. Alternatively you can look it up using the [UserInfo](/developers/api/identity/userinfo/index.md) endpoint with the appropriate Bearer token.

This `sub` stays consistent so you can safely store this against your own user record for ease of access.

Passing `managed_availability` set to `true` will respect [Availability Rules](/developers/scheduling/managed-availability/index.md) defined for the `Account`.

The second attribute is `required`  which indicates, in this case that all members have to be available for a slot to be returned.

In the second participant object we've used an example of a list of meeting rooms where you just need one to be available. Of course, this model can be used for choosing one or more people from a group.

### Required Duration
Fairly self-explanatory. The duration of the event you're looking for.

### Query Periods
This is an array of periods, described in UTC, that you wish to query for. A typical way to to derive this will be to calculate the standard working hours and generate an array of periods you want to query.

### Response Format
In this example `slots` is passed to indicate that you want the Cronofy Availability engine to do the slot calculation for you.

## Typical response
Returned is list of time periods that can support the 60 min meeting time we're queried for.

```json
{
  "available_slots": [
    {
      "start": "2026-09-09T09:00:00Z",
      "end": "2026-09-09T10:00:00Z",
      "participants": [
        { "sub": "acc_5ba21743f408617d1269ea1e" },
        { "sub": "acc_64b17d868090ea21640c914c" },
        { "sub": "res_64b17d868090ea21640ad6e0" }
      ]
    },
    {
      "start": "2026-09-10T16:00:00Z",
      "end": "2026-09-10T17:00:00Z",
      "participants": [
        { "sub": "acc_5ba21743f408617d1269ea1e" },
        { "sub": "acc_64b17d868090ea21640c914c" },
        { "sub": "res_5ba21743f4000563a26934ea" },
        { "sub": "res_64b17d868090ea21640ad6e0" }
      ]
    }
  ]
}
```

In this case both participants are available between 09:00 and 10:00 on September 9 and 16:00 and 17:00 on September 10 UTC.

In the first period there is also one meeting room available, in the second two meeting rooms are.

## Summary
This is deliberately a simple example to establish the core concepts of querying. You can explore the full [Availability API reference](/developers/api/scheduling/availability/index.md) for more details of options. We'll also be following up with additional help articles about individual working hours and more complex member selection amongst other uses.


---
[Read in HTML](/developers/scheduling/)

## In this section

- [Real-Time Scheduling](/developers/scheduling/real-time-scheduling/index.md) — Generate branded, self-serve booking links straight from your application.
- [Meeting Rooms](/developers/scheduling/meeting-rooms/index.md) — Meeting Rooms are treated as any another participant when using the Availability API. However there is a feature of the participants query element that is designed specifically to handle the querying requirements for meeting rooms.
- [Buffers](/developers/scheduling/buffers/index.md) — Specify an amount of time that must be free before and/or after an event
- [Constraints](/developers/scheduling/constraints/index.md) — Specify an amount of time that must be free before and/or after an event
- [Managed Availability](/developers/scheduling/managed-availability/index.md) — When managing an account's availability through Availability Rules or Available Periods you can then use those to impact on their availability when using the Real-Time Scheduling and Availability endpoints.
- [Ignoring Calendar Events](/developers/scheduling/ignoring-calendar-events/index.md) — There are situations where it makes sense to ignore the events in someone's calendars when generating a list of available slots. This article explains how to achieve that with the Cronofy Availability API.
- [Sequenced Availability](/developers/scheduling/sequenced-availability/index.md) — Scheduling a simple set of events is simply a case of making a sequence with the steps defined in the desired order.