> 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

# Get Note

GET https://api.calendly.com/notes/{uuid}

Returns one note that the authenticated user owns. The note has the same fields as in List Notes and Create Note.

If the note does not exist, or another user owns it, the request returns 404. The response does not show if the note exists.

**Note:** Requires the Contacts API on your plan.

> `contacts:read`

Reference: https://developer.calendly.com/api-docs/calendly-api/contacts/get-note

## Authentication

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

## Request

### Path parameters

- `uuid` (string, required) — The UUID of the note, from the end of its `uri`.

## Response

### 200

OK

- `resource` (Note, required) — A note that a user wrote about a contact. Only the user who owns a note can see it.

## Errors

### 400 Bad Request Error

Request is not valid

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

### 401 Unauthorized Error

Cannot authenticate caller

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

### 403 Forbidden Error

Permission Denied or insufficient scope

- `Get-noteRequestForbiddenError`
  - GetNoteError: GetNoteError
  - InsufficientScopeError: InsufficientScopeError

### 404 Not Found Error

Requested resource not found

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

### 429 Too Many Requests Error

Too Many Requests

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

### 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

### Note

A note that a user wrote about a contact. Only the user who owns a note can see it.

- `uri` (string, required) — Canonical reference (unique identifier) for the note.
- `title` (string, required, nullable) — The title of the note. `null` if the note has no title. Maximum 255 characters. Some emoji and other symbols count as 2.
- `body` (string, required, nullable) — The plain-text content of the note. `null` if the note has no body. Maximum 10,000 characters.
- `contact` (string, required, nullable) — The URI of the contact that the note is about. Never `null` when you filter by `contact`. `null` only for a note that has no contact.
- `remind_at` (string, required, nullable) — When the reminder is due. `null` if the note has no reminder.
- `completed_at` (string, required, nullable) — When the reminder was completed. `null` if the reminder is not complete or the note has no reminder.
- `created_at` (string, required) — When the note was created.
- `updated_at` (string, required) — When the note or its reminder was last changed.

### ErrorResponseDetailsItem

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

### GetNoteError

Permission Denied

- `title` (enum, required)
  - Allowed values: `Permission Denied`
- `message` (enum, required)
  - Allowed values: `Please upgrade to a paid Calendly account.`, `You do not have permission to access this resource.`

### 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
{
  "resource": {
    "uri": "https://api.calendly.com/notes/AAAAAAAAAAAAAAAA",
    "title": "Follow up",
    "body": "Send the revised proposal after Thursday's call.",
    "contact": "https://api.calendly.com/contacts/BBBBBBBBBBBBBBBB",
    "remind_at": "2026-10-02T16:00:00.000Z",
    "completed_at": null,
    "created_at": "2026-09-28T16:31:00.000Z",
    "updated_at": "2026-09-28T16:31:00.000Z"
  }
}
```

**SDK Code**

```python Note with a reminder
import requests

url = "https://api.calendly.com/notes/AAAAAAAAAAAAAAAA"

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

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

print(response.json())
```

```javascript Note with a reminder
const url = 'https://api.calendly.com/notes/AAAAAAAAAAAAAAAA';
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 Note with a reminder
package main

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

func main() {

	url := "https://api.calendly.com/notes/AAAAAAAAAAAAAAAA"

	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 Note with a reminder
require 'uri'
require 'net/http'

url = URI("https://api.calendly.com/notes/AAAAAAAAAAAAAAAA")

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 Note with a reminder
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.calendly.com/notes/AAAAAAAAAAAAAAAA")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Note with a reminder
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.calendly.com/notes/AAAAAAAAAAAAAAAA', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Note with a reminder
using RestSharp;

var client = new RestClient("https://api.calendly.com/notes/AAAAAAAAAAAAAAAA");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Note with a reminder
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.calendly.com/notes/AAAAAAAAAAAAAAAA")! 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()
```