> Calendly developer docs. For page Markdown, append .md to any URL.
> Index: https://developer.calendly.com/llms.txt
> API catalog: https://developer.calendly.com/.well-known/api-catalog
> OpenAPI: https://developer.calendly.com/openapi/calendly-api.yaml
> OAuth authorization server: https://calendly.com/.well-known/oauth-authorization-server
> MCP protected resource: https://mcp.calendly.com/.well-known/oauth-protected-resource
> Scheduling MCP endpoint: https://mcp.calendly.com
> Docs search MCP: https://developer.calendly.com/_mcp/server

# List User Meeting Limits

GET https://api.calendly.com/user_meeting_limits

Returns a user's host-level meeting limits (daily, weekly, and monthly caps across all Event Types).

The collection holds one item for the requested user and is not paginated. A user who has never set a limit gets an item with all three limit fields `null`, not an empty collection or a 404.

`user` must be the authenticated user. Any other user returns 403, including for an organization admin.

A limit counts every scheduled meeting the user hosts that is not canceled, across all of their Event Types. A meeting counts once, however many invitees it has. Events on connected calendars do not count. Days are measured in the timezone of the Event Type being booked, weeks run Sunday through Saturday, and months are calendar months. Limits are not applied to bookings made on someone else's behalf, or on Event Types that allow double booking.

> `availability:read`

Reference: https://developer.calendly.com/api-docs/calendly-api/availability/list-user-meeting-limits

## Authentication

- `Authorization` header (bearer token, required) — OAuth 2.0
- `Authorization` header (bearer token, required) — Personal Access Token

## Request

### Query parameters

- `user` (string, required) — A URI reference to a user

## Response

### 200

OK

- `collection` (list of UserMeetingLimits, required)

## Errors

### 400 Bad Request Error

Request is not valid

- `title` (enum, required)
  - Allowed values: `Invalid Argument`
- `message` (enum, required)
  - Allowed values: `The supplied parameters are invalid.`
- `details` (list of ErrorResponseDetailsItem, optional)

### 401 Unauthorized Error

Cannot authenticate caller

- `title` (enum, required)
  - Allowed values: `Unauthenticated`
- `message` (enum, required)
  - Allowed values: `The access token is invalid`, `The access token expired`, `The access token was revoked`
- `details` (list of ErrorResponseDetailsItem, optional)

### 403 Forbidden Error

Permission denied or insufficient scope

- `List-user-meeting-limitsRequestForbiddenError`
  - ListUserMeetingLimitsRequestForbiddenError0
  - InsufficientScopeError: InsufficientScopeError

### 404 Not Found Error

Requested resource not found

- `title` (enum, required)
  - Allowed values: `Resource Not Found`
- `message` (enum, required)
  - Allowed values: `The server could not find the requested resource.`
- `details` (list of ErrorResponseDetailsItem, optional)

### 429 Too Many Requests Error

Too Many Requests

- `title` (enum, required)
  - Allowed values: `Too Many Requests`
- `message` (enum, required)
  - Allowed values: `Rate limit exceeded. Please retry after some time.`
- `details` (list of ErrorResponseDetailsItem, optional)

### 500 Internal Server Error

An error has occurred on the server

- `title` (enum, required)
  - Allowed values: `Internal Server Error`
- `message` (enum, required)
  - Allowed values: `The server encountered an unexpected condition that prevented it from fulfilling the request.`
- `details` (list of ErrorResponseDetailsItem, optional)

## Types

### UserMeetingLimits

Host-level meeting limits for a user across all of their Event Types.

- `user` (string, required) — URI of the user these limits belong to.
- `daily_limit` (integer, required, nullable) — Most meetings the user can be booked into in a day, across all of their Event Types. `null` when no daily limit is set. A set value is a whole number from 1 to 9999.
- `weekly_limit` (integer, required, nullable) — Most meetings the user can be booked into in a week, across all of their Event Types. `null` when no weekly limit is set. A set value is a whole number from 1 to 9999.
- `monthly_limit` (integer, required, nullable) — Most meetings the user can be booked into in a month, across all of their Event Types. `null` when no monthly limit is set. A set value is a whole number from 1 to 9999.

### ErrorResponseDetailsItem

- `message` (string, required)
- `parameter` (string, optional)
- `code` (string, optional)

### ListUserMeetingLimitsRequestForbiddenError0

Error Object

- `title` (enum, required)
  - Allowed values: `Permission Denied`
- `message` (enum, required)
  - Allowed values: `You do not have permission to access this resource.`, `You do not have permission`
- `details` (list of ErrorResponseDetailsItem, optional)

### InsufficientScopeError

Caller does not have required oauth scopes

- `title` (enum, required)
  - Allowed values: `Insufficient scope`
- `message` (enum, required)
  - Allowed values: `This operation requires the scopes listed in the 'required_scopes' array.`
- `required_scopes` (list of string, required)

## Examples

**Response**

```json
{
  "collection": [
    {
      "user": "https://api.calendly.com/users/AAAAAAAAAAAAAAAA",
      "daily_limit": 4,
      "weekly_limit": null,
      "monthly_limit": 60
    }
  ]
}
```

**SDK Code**

```python User meeting limits
import requests

url = "https://api.calendly.com/user_meeting_limits"

querystring = {"user":"https://api.calendly.com/users/AAAAAAAAAAAAAAAA"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript User meeting limits
const url = 'https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go User meeting limits
package main

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

func main() {

	url := "https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

```ruby User meeting limits
require 'uri'
require 'net/http'

url = URI("https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java User meeting limits
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp User meeting limits
using RestSharp;

var client = new RestClient("https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift User meeting limits
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.calendly.com/user_meeting_limits?user=https%3A%2F%2Fapi.calendly.com%2Fusers%2FAAAAAAAAAAAAAAAA")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```