# Apple Subscription
Source: https://docs.meetjamie.ai/billing-pricing/apple-subscription
Learn how to view, change, or cancel your Jamie subscription purchased through the Apple App Store.
If you subscribed to Jamie through the Apple App Store, you can manage your subscription directly from your device. Below you'll find step-by-step instructions for both Mac and iPhone.
With an Apple subscription, you can only upgrade to the **Personal (Pro & Plus)** plans. If you'd like to switch to a **Team** or **Enterprise** plan, please reach out to us at [support@meetjamie.ai](mailto:support@meetjamie.ai) and we'll help you get set up.
## Manage your subscription
You can manage your Jamie subscription directly from the Settings app on your iPhone.
Open the **Settings** app on your iPhone.
Tap your **name** at the top of the Settings screen to open your Apple Account settings.
Tap **Subscriptions**. You'll see a list of all your active and expired subscriptions.
Tap the **Jamie** subscription from the list.
From here, you can:
* **Change your plan** — Select a different option from the available plans.
* **Cancel your subscription** — Tap **Cancel Subscription** and confirm. You may need to scroll down to find this button.
If there's no Cancel button or you see an expiration message in red text, the subscription is already canceled.
On Mac, you manage your subscriptions through **System Settings**.
Open the **System Settings** app on your Mac.
Click your **name** at the top of the sidebar to open your Apple Account settings. If you don't see your name, click **Sign In** first.
Click **Media & Purchases**.
Click **Manage** next to **Subscriptions**.
Find and select the **Jamie** subscription from the list.
From here, you can:
* **Change your plan** — Select a different option from the available plans.
* **Cancel your subscription** — Click **Cancel Subscription** and confirm. You may need to scroll down to find this button.
If there's no Cancel button or you see an expiration message in red text, the subscription is already canceled.
## FAQs
No. Apple subscriptions only support upgrades to the Personal (Pro & Plus) plans. If you'd like to move to a Team or Enterprise plan, please contact us at [support@meetjamie.ai](mailto:support@meetjamie.ai).
After you cancel, your subscription remains active until the end of your current billing period. You won't be charged again, and you can continue using Jamie until the period expires.
Make sure you're signed in with the same Apple Account you used when you originally subscribed. If you're still having trouble, check your email for a receipt from Apple to confirm which account was used.
# Invoices
Source: https://docs.meetjamie.ai/billing-pricing/invoices
How to download your invoices in Jamie.
You have recently upgraded your Jamie account to a paid plan, and you would now like to **download your invoice**?
You can easily download your invoices (and receipts) by opening our **Billing portal** in your Jamie app and downloading the relevant invoice under “Invoice History”.
### Step by step:
1. Go to your **Settings**
2. Select **Team & Billing** in the settings menu
3. Click on **Billing portal** in the top right
4. Open the relevant invoice under **Invoice History**
5. Click **Download invoice**
# Subscriptions & Plans
Source: https://docs.meetjamie.ai/billing-pricing/subscriptions-plans
How do credits work and what if they are used up?
For every meeting recorded with Jamie, one credit is charged, regardless of the duration of the meeting. If meetings are too short for Jamie to create a proper summary, no credit is charged.
Below you can see how many credits you have depending on what plan you are on:
**0€**
Meeting credits: 10 per month
Meeting duration limitation: 30m per meeting
**25€ per month**
Meeting credits: 20 per month
Meeting duration limitation: 2h per meeting
**47€ per month**
Meeting credits: Unlimited per month
Meeting duration limitation: 5h per meeting
**39€ per member**
Meeting credits: Unlimited per month
Meeting duration limitation: 5h per meeting
**Custom pricing**
Meeting credits: Unlimited per month
Meeting duration limitation: 5h per meeting
Jamie has several plans to fit different needs, from individuals just starting out, to large teams with more meetings.
Once you have used all your credits in Jamie, your meeting notes will be locked, and you will need to upgrade to a paid plan to access them. This can either be because you've reached the maximum credits or exceeded the allowed duration limit of your free or paid plan.
You can find all detailed information on the different plans on our [Pricing Page](https://www.meetjamie.ai/pricing).
If you have more questions on using Jamie with your entire team or organization, then please contact our team at [support@meetjamie.ai](mailto:support@meetjamie.ai).
### FAQs
Once you go over the meeting credit limit or extend the duration limit, your summary will be locked.
To unlock any meeting summaries for meetings that went over time or credit limit, simply upgrade to one of the higher tier plans.
In your settings under billing, you can see how many credits you have on a monthly basis and how many you have already used.
Just go to your settings and click on billing. It will show you your current plan, how many credits you have used, and when the plan will be renewed.
To cancel your subscription, go to your billing settings and click the Manage button - there is an option to cancel your subscription.
Jamie has two custom vocabulary lists that improve transcription accuracy: a personal list (per user) and a team list (shared across your workspace). Each term can be up to 100 characters long.
How many terms each list can hold depends on your plan:
* **Free, Plus & Pro**: 50 terms per list
* **Team**: 100 terms per list
* **Enterprise**: 250 terms per list
You can manage both lists in your settings under Personalization.
You can cancel a Team subscription only after removing all other workspace members. After cancellation, inviting new members is disabled. You’ll stay on the Pro plan for the remainder of the current billing period, at which point your plan will switch to the Free plan.
# Access & Security
Source: https://docs.meetjamie.ai/developers/api/access-and-security
API key scopes, rate limits, and error handling
## API Key Scopes
There are two types of API keys. Each key type uses its own set of routes:
* **Personal keys** use `/v1/me/` routes
* **Workspace keys** use `/v1/workspace/` routes
Using a key on the wrong route set will return a `403` error. Both route sets use the same request format — see [Getting Started](/developers/api/getting-started).
| | Personal Key | Workspace Key |
| ---------------------- | -------------------------------------------------------------------------- | ----------------------------------------- |
| **Routes** | `/v1/me/*` | `/v1/workspace/*` |
| **Created by** | Any workspace member | Workspace admins only |
| **Meetings access** | Your own meetings + meetings shared with you (directly or via shared tags) | All meetings across the workspace |
| **Tasks access** | Tasks from your meetings + tasks from shared meetings | All tasks across the workspace |
| **Delete meetings** | Your own meetings only | Any meeting in the workspace |
| **Search** | Full-text meeting search | Not available |
| **Tags** | List your tags | Not available |
| **`userEmail` filter** | Not available | Filter results by a specific user's email |
| **Rate limit scope** | 100 requests/min per user | 100 requests/min per workspace |
| **Max keys** | 3 per user | 10 per workspace |
If you only need access to your own data, use a **Personal** key. Use a **Workspace** key when you need to query across all team members or filter by user.
### Shared Meeting Access (Personal Keys)
Personal keys don't just return your own meetings — they also include meetings that have been shared with you:
* **Directly shared** — Meetings explicitly shared with you by a teammate
* **Shared via tags** — Meetings tagged with a label that's been shared with you
This applies to both meeting listing and task listing. Deleting meetings is restricted to meetings you own.
## Rate Limiting
API requests are limited to **100 requests per minute**.
* **Personal keys** — The limit applies per user. Each user with their own key gets their own quota.
* **Workspace keys** — The limit applies per workspace. All workspace keys share the same quota.
When you exceed the limit, you'll receive a `429 Too Many Requests` response with these headers:
| Header | Description |
| ----------------------- | ---------------------------------------- |
| `X-RateLimit-Limit` | Maximum requests allowed per window |
| `X-RateLimit-Remaining` | Requests remaining in the current window |
| `X-RateLimit-Reset` | Unix timestamp when the window resets |
## Error Responses
All errors return a JSON object with an `error` field:
```json theme={null}
{
"error": "Description of what went wrong"
}
```
### Status Codes
| Status | Meaning | Common Causes |
| ------ | ----------------- | ----------------------------------------------------------------------- |
| `200` | Success | Request completed successfully |
| `400` | Bad Request | Invalid parameters — malformed dates, bad cursor format, missing fields |
| `401` | Unauthorized | Missing or invalid API key |
| `403` | Forbidden | Wrong key type for route, or insufficient access |
| `404` | Not Found | Meeting or resource doesn't exist |
| `429` | Too Many Requests | Rate limit exceeded — wait and retry |
| `500` | Internal Error | Something went wrong on our end — please retry |
### Common Error Examples
**Missing API key:**
```json theme={null}
{ "error": "Missing API key. Use header: x-api-key: " }
```
**Wrong key type for route:**
```json theme={null}
{ "error": "This endpoint requires a workspace-scoped API key." }
```
**No access to a meeting:**
```json theme={null}
{ "error": "Access denied. You do not have access to this meeting." }
```
**Invalid query parameter:**
```json theme={null}
{ "error": "Invalid startDate format" }
```
# Overview
Source: https://docs.meetjamie.ai/developers/api/api
Programmatic access to your Jamie meeting data
The Jamie API lets you programmatically access your meeting data — summaries, transcripts, tasks, and more. Build custom integrations, sync meeting insights into your tools, or create dashboards tailored to your workflow.
## Base URL
```text theme={null}
https://beta-api.meetjamie.ai
```
## What You Can Do
List, fetch, search, and delete meetings
Query action items from your meetings
List your tags and filter meetings by tag
## Quick Start
1. Make sure you're on a **Pro**, **Team**, or **Enterprise** plan
2. Create an API key in **Settings → Developers → API Keys**
3. Start making requests:
```bash theme={null}
# With a workspace key
curl -H "x-api-key: jk_your_workspace_key" \
"https://beta-api.meetjamie.ai/v1/workspace/meetings.list"
# With a personal key
curl -H "x-api-key: jk_your_personal_key" \
"https://beta-api.meetjamie.ai/v1/me/meetings.list"
```
No OAuth flows, no tokens to refresh. Just a single API key in the `x-api-key` header.
Use the **Request Builder** in **Settings → Developers → API Keys** to visually construct requests with the right parameters — no manual URL formatting needed.
## Route Structure
The API has two route sets — one for each key type. Both use the same request format.
### `/v1/workspace/` — Workspace keys
| Method | Endpoint | Description |
| ------ | ------------------------------- | --------------------------------------------------------------------- |
| `GET` | `/v1/workspace/meetings.list` | [List all workspace meetings](/developers/api/meetings/list-meetings) |
| `GET` | `/v1/workspace/meetings.get` | [Get meeting details](/developers/api/meetings/get-meeting) |
| `POST` | `/v1/workspace/meetings.delete` | [Delete a meeting](/developers/api/meetings/delete-meeting) |
| `GET` | `/v1/workspace/tasks.list` | [List all workspace tasks](/developers/api/tasks/list-tasks) |
### `/v1/me/` — Personal keys
| Method | Endpoint | Description |
| ------ | ------------------------ | -------------------------------------------------------------------------------- |
| `GET` | `/v1/me/meetings.list` | [List your meetings + shared meetings](/developers/api/meetings/list-meetings) |
| `GET` | `/v1/me/meetings.get` | [Get meeting details](/developers/api/meetings/get-meeting) |
| `POST` | `/v1/me/meetings.delete` | [Delete a meeting you own](/developers/api/meetings/delete-meeting) |
| `GET` | `/v1/me/meetings.search` | [Search across your meetings](/developers/api/meetings/search-meetings) |
| `GET` | `/v1/me/tasks.list` | [List your tasks + tasks from shared meetings](/developers/api/tasks/list-tasks) |
| `GET` | `/v1/me/tags.list` | [List your tags](/developers/api/tags/list-tags) |
New to the API? Start with [Getting Started](/developers/api/getting-started) to create your key and make your first request. Then read [Access & Security](/developers/api/access-and-security) to understand key scopes and rate limits.
# Getting Started
Source: https://docs.meetjamie.ai/developers/api/getting-started
Create an API key and make your first request
## Prerequisites
* An eligible plan — API access is available on **Pro**, **Team**, and **Enterprise** plans.
* An API key — Create one in **Settings → Developers → API Keys**.
## Creating an API Key
1. Navigate to **Settings → Developers → API Keys**
2. Click **Add API Key**
3. If you're an admin, choose the scope: **Personal** or **Workspace** (see [Access & Security](/developers/api/access-and-security) for the difference)
4. Enter a name and optional description
5. Click **Create API Key**
6. **Copy your key immediately** — it won't be shown again
Store your API key securely. If you lose it, you'll need to regenerate it from the API key settings. Treat it like a password.
## Authentication
Every request must include your API key in the `x-api-key` header.
API keys start with the `jk_` prefix. If the key is missing or invalid, you'll receive a `401 Unauthorized` response.
## Making Requests
Both key types use the same request format:
* **Reading data** uses **GET** with optional parameters via `?input={"json": { ... }}`
* **Deleting** uses **POST** with a JSON body
* When no parameters are needed, just call the URL directly
The only difference is the route prefix: `/v1/workspace/` for workspace keys, `/v1/me/` for personal keys.
### Examples
**List meetings (no parameters):**
```bash theme={null}
# Workspace key
curl -H "x-api-key: jk_your_workspace_key" \
"https://beta-api.meetjamie.ai/v1/workspace/meetings.list"
# Personal key
curl -H "x-api-key: jk_your_personal_key" \
"https://beta-api.meetjamie.ai/v1/me/meetings.list"
```
**List meetings with filters:**
```bash theme={null}
# Workspace key — filter by user and limit
curl -H "x-api-key: jk_your_workspace_key" \
'https://beta-api.meetjamie.ai/v1/workspace/meetings.list?input={"json":{"limit":5,"userEmail":"sarah@example.com"}}'
# Personal key — filter by tag
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.list?input={"json":{"limit":5,"tag":"Product"}}'
```
**Get a specific meeting:**
```bash theme={null}
curl -H "x-api-key: jk_your_key" \
'https://beta-api.meetjamie.ai/v1/workspace/meetings.get?input={"json":{"meetingId":"YOUR_MEETING_ID"}}'
```
**List open tasks:**
```bash theme={null}
curl -H "x-api-key: jk_your_key" \
'https://beta-api.meetjamie.ai/v1/workspace/tasks.list?input={"json":{"completed":false,"limit":10}}'
```
**Delete a meeting (POST):**
```bash theme={null}
curl -X POST -H "x-api-key: jk_your_key" \
-H "Content-Type: application/json" \
-d '{"json": {"meetingId": "YOUR_MEETING_ID"}}' \
"https://beta-api.meetjamie.ai/v1/workspace/meetings.delete"
```
**Search meetings (personal key only):**
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.search?input={"json":{"query":"product roadmap"}}'
```
**List your tags (personal key only):**
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
"https://beta-api.meetjamie.ai/v1/me/tags.list"
```
**Don't want to build requests by hand?** Use the **Request Builder** in **Settings → Developers → API Keys** to visually select an endpoint, add parameters, and get a ready-to-use cURL command or URL you can copy.
**Cheat sheet:**
* URL pattern: `/v1/{workspace or me}/{procedure}` (e.g., `/v1/workspace/meetings.list`)
* Reading: `GET` with optional `?input={"json": {...}}`
* Deleting: `POST` with body `{"json": {...}}`
* No parameters? Just call the URL directly
### Response Format
All responses wrap data in an envelope:
```json theme={null}
{
"result": {
"data": {
"json": {
"meetings": [...],
"nextCursor": null
}
}
}
}
```
Your data is inside `result.data.json`.
## Pagination
List endpoints return paginated results. When more data is available, the response includes a `nextCursor` field. Pass it in your next request:
```bash theme={null}
GET /v1/workspace/meetings.list?input={"json":{"limit":20,"cursor":"2024-11-27T14:00:00.000Z::7893456789012345678"}}
```
When `nextCursor` is `null`, you've reached the end of the results.
# Delete Meeting
Source: https://docs.meetjamie.ai/developers/api/meetings/delete-meeting
Permanently delete a meeting and all its related data
Permanently deletes a meeting and all its related data — including the summary, transcript, and tasks.
This action is permanent and cannot be undone. All meeting data including the summary, transcript, and tasks will be permanently removed.
```
POST /v1/workspace/meetings.delete
```
Delete any meeting in the workspace (the meeting owner must be a workspace member).
```bash theme={null}
curl -X POST -H "x-api-key: jk_your_workspace_key" \
-H "Content-Type: application/json" \
-d '{"json": {"meetingId": "7893456789012345678"}}' \
"https://beta-api.meetjamie.ai/v1/workspace/meetings.delete"
```
```
POST /v1/me/meetings.delete
```
Delete meetings you own. You cannot delete meetings that were shared with you.
```bash theme={null}
curl -X POST -H "x-api-key: jk_your_personal_key" \
-H "Content-Type: application/json" \
-d '{"json": {"meetingId": "7893456789012345678"}}' \
"https://beta-api.meetjamie.ai/v1/me/meetings.delete"
```
## Parameters
| Parameter | Type | Description |
| ----------- | ------ | -------------- |
| `meetingId` | string | The meeting ID |
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"success": true,
"message": "Meeting deleted successfully",
"deletedMeetingId": "7893456789012345678"
}
}
}
}
```
## Error Responses
| Status | Error | Cause |
| ------ | ---------------------------------------------------------------- | --------------------------------------------------------- |
| `403` | `Access denied. This meeting does not belong to your workspace.` | Workspace key — the meeting owner isn't in your workspace |
| `403` | `Access denied. You can only delete your own meetings.` | Personal key — you don't own this meeting |
| `404` | `Meeting not found` | No meeting exists with this ID |
# Get Meeting
Source: https://docs.meetjamie.ai/developers/api/meetings/get-meeting
Retrieve full details for a single meeting
Returns the full details for a single meeting, including summary, transcript, participants, tasks, tags, and calendar event info. With a personal key, meetings you own also include your scratchpad notes as Markdown.
```text theme={null}
GET /v1/workspace/meetings.get
```
Retrieve any meeting in the workspace.
```bash theme={null}
curl -H "x-api-key: jk_your_workspace_key" \
'https://beta-api.meetjamie.ai/v1/workspace/meetings.get?input={"json":{"meetingId":"7893456789012345678"}}'
```
```text theme={null}
GET /v1/me/meetings.get
```
Retrieve meetings you own or that have been shared with you.
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.get?input={"json":{"meetingId":"7893456789012345678"}}'
```
## Parameters
| Parameter | Type | Description |
| ----------- | ------ | -------------- |
| `meetingId` | string | The meeting ID |
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"id": "7893456789012345678",
"title": "Q4 Planning Meeting",
"generatedTitle": "Q4 Product Roadmap Review",
"startTime": "2024-11-27T14:00:00.000Z",
"endTime": "2024-11-27T15:00:00.000Z",
"user": {
"id": "user-456",
"email": "sarah.johnson@example.com"
},
"summary": {
"markdown": "# Meeting Summary\n\n## Key Discussion Points\n• Reviewed Q4 roadmap...",
"html": "Meeting Summary
Key Discussion Points
",
"short": "Q4 product planning meeting covering roadmap priorities and mobile redesign."
},
"transcript": "**Sarah Johnson**\nHi everyone! Thanks for joining today's meeting.\n\n**Alex Chen**\nThanks for having me. Let's dive into the agenda.",
"scratchpadNotes": "## Follow-up\n\nSend Alex the revised product brief.",
"participants": [
{
"id": "1",
"name": "Sarah Johnson",
"email": "sarah.johnson@example.com"
},
{
"id": "2",
"name": "Alex Chen",
"email": "alex.chen@example.com"
}
],
"tasks": [
{
"content": "Finalize technical specifications for mobile app redesign",
"completed": false,
"assignee": {
"name": "Alex Chen",
"email": "alex.chen@example.com"
}
}
],
"tags": [
{
"name": "Product",
"color": "#4A90D9"
}
],
"event": {
"id": "calendar-event-123",
"externalId": "AAMkAGI1AAAt9AHjAAA=",
"title": "Q4 Planning Meeting",
"scheduledTime": "2024-11-27T14:00:00.000Z",
"endTime": "2024-11-27T15:00:00.000Z",
"attendees": [
{
"name": "Sarah Johnson",
"email": "sarah.johnson@example.com",
"responseStatus": "accepted",
"organizer": true
},
{
"name": "Alex Chen",
"email": "alex.chen@example.com",
"responseStatus": "accepted",
"organizer": false
}
]
}
}
}
}
}
```
## Response Fields
### Top-level
| Field | Type | Description |
| ---------------- | -------------- | ------------------- |
| `id` | string | Unique meeting ID |
| `title` | string | Meeting title |
| `generatedTitle` | string \| null | AI-generated title |
| `startTime` | string | ISO 8601 start time |
| `endTime` | string \| null | ISO 8601 end time |
### `user`
The Jamie user who recorded the meeting.
| Field | Type | Description |
| ------- | ------ | ----------- |
| `id` | string | User ID |
| `email` | string | User email |
### `summary`
| Field | Type | Description |
| ---------- | ------ | ------------------------------------- |
| `markdown` | string | Meeting summary formatted as Markdown |
| `html` | string | Meeting summary formatted as HTML |
| `short` | string | A brief one-line summary |
### `transcript`
The full meeting transcript as a markdown-formatted string. Speaker names are bolded, followed by their spoken text.
### `scratchpadNotes`
Your private scratchpad notes as a Markdown-formatted string. This field is returned by `/v1/me/meetings.get` when you own the meeting. It is `null` for meetings shared with you or when the meeting has no scratchpad notes. Workspace-key responses do not include private scratchpad notes.
### `participants`
People who actually spoke during the meeting (detected from the transcript).
| Field | Type | Description |
| ------- | -------------- | ---------------------------- |
| `id` | string | Participant ID |
| `name` | string | Display name |
| `email` | string \| null | Email address (if available) |
### `tasks`
Action items extracted from the meeting.
| Field | Type | Description |
| ---------------- | -------------- | ---------------------------------- |
| `content` | string | Task description |
| `completed` | boolean | Whether the task is marked as done |
| `assignee` | object \| null | Assigned person (if any) |
| `assignee.name` | string | Assignee name |
| `assignee.email` | string \| null | Assignee email |
### `tags`
Tags (labels) applied to the meeting.
| Field | Type | Description |
| ------- | ------ | --------------------------- |
| `name` | string | Tag name |
| `color` | string | Hex color (e.g., `#4A90D9`) |
### `event`
Calendar event information. Present even if no calendar event is linked (falls back to meeting data).
| Field | Type | Description |
| ---------------------------- | -------------- | ------------------------------------------------------------------------------ |
| `id` | string \| null | Internal Jamie calendar event ID |
| `externalId` | string \| null | The calendar provider's event ID (e.g., Microsoft Graph or Google Calendar ID) |
| `title` | string | Event title (falls back to meeting title) |
| `scheduledTime` | string | ISO 8601 start time |
| `endTime` | string \| null | ISO 8601 end time |
| `attendees` | array | People invited to the calendar event |
| `attendees[].name` | string | Attendee name |
| `attendees[].email` | string | Attendee email |
| `attendees[].responseStatus` | string \| null | RSVP status: `accepted`, `declined`, `tentative`, or `needsAction` |
| `attendees[].organizer` | boolean | Whether this attendee organized the event |
**Participants vs. Attendees**: `participants` are people who spoke during the meeting (detected from the transcript). `attendees` are people invited to the calendar event — they may or may not have attended or spoken.
# List Meetings
Source: https://docs.meetjamie.ai/developers/api/meetings/list-meetings
Retrieve a paginated list of meetings
Returns a paginated list of meetings, ordered by start time (newest first).
```
GET /v1/workspace/meetings.list
```
Returns all meetings across the workspace.
### Parameters
| Parameter | Type | Default | Description |
| ----------- | ------ | ------- | ------------------------------------------------------------------- |
| `limit` | number | `50` | Number of meetings to return (max `100`) |
| `cursor` | string | — | Pagination cursor from a previous response |
| `startDate` | string | — | ISO 8601 date. Only return meetings starting on or after this date |
| `endDate` | string | — | ISO 8601 date. Only return meetings starting on or before this date |
| `userEmail` | string | — | Filter by a specific user's email |
### Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_workspace_key" \
'https://beta-api.meetjamie.ai/v1/workspace/meetings.list?input={"json":{"limit":10,"startDate":"2024-11-01T00:00:00Z"}}'
```
**Filter by user:**
```bash theme={null}
curl -H "x-api-key: jk_your_workspace_key" \
'https://beta-api.meetjamie.ai/v1/workspace/meetings.list?input={"json":{"limit":5,"userEmail":"sarah@example.com"}}'
```
```
GET /v1/me/meetings.list
```
Returns your own meetings plus meetings shared with you (directly or via shared tags).
### Parameters
| Parameter | Type | Default | Description |
| ----------- | ------ | ------- | ------------------------------------------------------------------- |
| `limit` | number | `50` | Number of meetings to return (max `100`) |
| `cursor` | string | — | Pagination cursor from a previous response |
| `startDate` | string | — | ISO 8601 date. Only return meetings starting on or after this date |
| `endDate` | string | — | ISO 8601 date. Only return meetings starting on or before this date |
| `tag` | string | — | Filter by tag name |
### Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.list?input={"json":{"limit":10,"startDate":"2024-11-01T00:00:00Z"}}'
```
**Filter by tag:**
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.list?input={"json":{"limit":5,"tag":"Product"}}'
```
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"meetings": [
{
"id": "7893456789012345678",
"title": "Q4 Planning Meeting",
"generatedTitle": "Q4 Product Roadmap Review",
"startTime": "2024-11-27T14:00:00.000Z",
"endTime": "2024-11-27T15:00:00.000Z",
"calendarEventId": "calendar-event-123",
"userId": "user-456"
}
],
"nextCursor": "2024-11-20T10:00:00.000Z::7893456789012345677"
}
}
}
}
```
## Response Fields
| Field | Type | Description |
| ---------------------------- | -------------- | ------------------------------------------------------ |
| `meetings` | array | List of meeting objects |
| `meetings[].id` | string | Unique meeting ID |
| `meetings[].title` | string | Meeting title |
| `meetings[].generatedTitle` | string \| null | AI-generated title |
| `meetings[].startTime` | string | ISO 8601 start time |
| `meetings[].endTime` | string \| null | ISO 8601 end time |
| `meetings[].calendarEventId` | string \| null | Linked calendar event ID |
| `meetings[].userId` | string | ID of the user who recorded the meeting |
| `nextCursor` | string \| null | Cursor for the next page, or `null` if no more results |
# Search Meetings
Source: https://docs.meetjamie.ai/developers/api/meetings/search-meetings
Semantic search across your meeting content
```
GET /v1/me/meetings.search
```
Searches across your meetings using semantic similarity matching. Returns matching text chunks with their source meeting. Only available with a **personal** API key.
Results are drawn from meetings within the last 6 months by default, returning up to 40 matches ranked by relevance.
## Parameters
| Parameter | Type | Description |
| ----------- | ------ | ------------------------------------------------------------------- |
| `query` | string | **Required.** The search query |
| `startDate` | string | ISO 8601 date. Only search meetings starting on or after this date |
| `endDate` | string | ISO 8601 date. Only search meetings starting on or before this date |
## Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.search?input={"json":{"query":"product roadmap"}}'
```
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"results": [
{
"id": "chunk-001",
"text": "We need to finalize the product roadmap for Q1 before the holidays...",
"meetingId": "7893456789012345678",
"meetingTitle": "Q4 Planning Meeting",
"meetingDate": "2024-11-27"
},
{
"id": "chunk-002",
"text": "The roadmap priorities should focus on mobile redesign and API improvements...",
"meetingId": "7893456789012345679",
"meetingTitle": "Product Sync",
"meetingDate": "2024-11-20"
}
]
}
}
}
}
```
## Response Fields
| Field | Type | Description |
| ------------------------ | -------------- | ------------------------------------------------- |
| `results` | array | List of matching text chunks, ranked by relevance |
| `results[].id` | string | Unique chunk ID |
| `results[].text` | string | The matching text excerpt |
| `results[].meetingId` | string | ID of the source meeting |
| `results[].meetingTitle` | string \| null | Title of the source meeting |
| `results[].meetingDate` | string | Date of the meeting (`YYYY-MM-DD`) |
## Common Patterns
**Search with a date range:**
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/meetings.search?input={"json":{"query":"hiring plan","startDate":"2024-10-01T00:00:00Z","endDate":"2024-12-01T00:00:00Z"}}'
```
This endpoint is only available with a personal API key. It searches across your own meetings and meetings shared with you.
# List Tags
Source: https://docs.meetjamie.ai/developers/api/tags/list-tags
Retrieve all tags available to you
```
GET /v1/me/tags.list
```
Returns all tags (labels) that you own or that have been shared with you. Only available with a **personal** API key. No parameters required.
## Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
"https://beta-api.meetjamie.ai/v1/me/tags.list"
```
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"tags": [
{
"id": "tag-001",
"name": "Product",
"shared": false
},
{
"id": "tag-002",
"name": "Engineering",
"shared": true
}
]
}
}
}
}
```
## Response Fields
| Field | Type | Description |
| --------------- | ------- | ----------------------------------------------------------------------------- |
| `tags` | array | List of tag objects |
| `tags[].id` | string | Unique tag ID |
| `tags[].name` | string | Tag name |
| `tags[].shared` | boolean | `true` if this tag was shared with you by another user, `false` if you own it |
Use the tag name with the `tag` parameter on [`/v1/me/meetings.list`](/developers/api/meetings/list-meetings) to filter meetings by tag.
# List Tasks
Source: https://docs.meetjamie.ai/developers/api/tasks/list-tasks
Retrieve action items extracted from your meetings
Returns a paginated list of action items extracted from meetings, ordered by creation date (newest first).
```
GET /v1/workspace/tasks.list
```
Returns all tasks across the workspace.
### Parameters
| Parameter | Type | Default | Description |
| ----------- | ------- | ------- | --------------------------------------------------------------- |
| `limit` | number | `50` | Number of tasks to return (max `100`) |
| `cursor` | string | — | Pagination cursor from a previous response |
| `startDate` | string | — | ISO 8601 date. Only return tasks created on or after this date |
| `endDate` | string | — | ISO 8601 date. Only return tasks created on or before this date |
| `userEmail` | string | — | Filter by a specific user's email |
| `completed` | boolean | — | Filter by completion status (`true` or `false`) |
| `meetingId` | string | — | Filter tasks from a specific meeting |
### Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_workspace_key" \
'https://beta-api.meetjamie.ai/v1/workspace/tasks.list?input={"json":{"completed":false,"limit":20}}'
```
```
GET /v1/me/tasks.list
```
Returns tasks from your own meetings and meetings shared with you.
### Parameters
| Parameter | Type | Default | Description |
| ----------- | ------- | ------- | --------------------------------------------------------------- |
| `limit` | number | `50` | Number of tasks to return (max `100`) |
| `cursor` | string | — | Pagination cursor from a previous response |
| `startDate` | string | — | ISO 8601 date. Only return tasks created on or after this date |
| `endDate` | string | — | ISO 8601 date. Only return tasks created on or before this date |
| `completed` | boolean | — | Filter by completion status (`true` or `false`) |
| `meetingId` | string | — | Filter tasks from a specific meeting |
### Example Request
```bash theme={null}
curl -H "x-api-key: jk_your_personal_key" \
'https://beta-api.meetjamie.ai/v1/me/tasks.list?input={"json":{"completed":false,"limit":20}}'
```
## Example Response
```json theme={null}
{
"result": {
"data": {
"json": {
"tasks": [
{
"id": "8901234567890123456",
"text": "Finalize technical specifications for mobile app redesign",
"completed": false,
"assignee": {
"id": "person-789",
"name": "Alex Chen",
"email": "alex.chen@example.com"
},
"meetingId": "7893456789012345678",
"meetingTitle": "Q4 Planning Meeting",
"createdAt": "2024-11-27T15:00:00.000Z",
"userId": "user-456"
},
{
"id": "8901234567890123457",
"text": "Schedule follow-up meeting for next week",
"completed": true,
"assignee": null,
"meetingId": "7893456789012345678",
"meetingTitle": "Q4 Planning Meeting",
"createdAt": "2024-11-27T15:00:00.000Z",
"userId": "user-456"
}
],
"nextCursor": "2024-11-20T10:00:00.000Z"
}
}
}
}
```
## Response Fields
| Field | Type | Description |
| ------------------------ | -------------- | ------------------------------------------------------ |
| `tasks` | array | List of task objects |
| `tasks[].id` | string | Unique task ID |
| `tasks[].text` | string | Task description |
| `tasks[].completed` | boolean | Whether the task is marked as done |
| `tasks[].assignee` | object \| null | Assigned person (if any) |
| `tasks[].assignee.id` | string \| null | Assignee person ID |
| `tasks[].assignee.name` | string | Assignee name |
| `tasks[].assignee.email` | string \| null | Assignee email |
| `tasks[].meetingId` | string | ID of the meeting this task was extracted from |
| `tasks[].meetingTitle` | string \| null | Title of the source meeting |
| `tasks[].createdAt` | string | ISO 8601 timestamp when the task was created |
| `tasks[].userId` | string | ID of the user who recorded the meeting |
| `nextCursor` | string \| null | Cursor for the next page, or `null` if no more results |
## Common Patterns
**Get all open tasks:**
```bash theme={null}
curl -H "x-api-key: jk_your_key" \
'https://beta-api.meetjamie.ai/v1/workspace/tasks.list?input={"json":{"completed":false}}'
```
**Get tasks from a specific meeting:**
```bash theme={null}
curl -H "x-api-key: jk_your_key" \
'https://beta-api.meetjamie.ai/v1/workspace/tasks.list?input={"json":{"meetingId":"7893456789012345678"}}'
```
**Get tasks from the last 7 days:**
```bash theme={null}
curl -H "x-api-key: jk_your_key" \
'https://beta-api.meetjamie.ai/v1/workspace/tasks.list?input={"json":{"startDate":"2024-11-20T00:00:00Z"}}'
```
# Delivery & Retries
Source: https://docs.meetjamie.ai/developers/webhooks/delivery-retries
How webhook deliveries work & how to test them
### Delivery Expectations
* **Timeout**: Webhook requests time out after **30 seconds**
* **Success**: Your endpoint should return a 2xx HTTP status code to acknowledge receipt
* **Response Body**: The response body is not processed (you can return any content or leave it empty)
### Retry Behavior
If your endpoint doesn't respond with a 2xx status code, Jamie automatically retries the delivery with exponential backoff:
| Attempt | Delay | Total Time Elapsed |
| :------ | :--------- | :----------------- |
| 1 | Immediate | 0s |
| 2 | 10 seconds | 10s |
| 3 | 60 seconds | 1m 10s |
| 4 | 10 minutes | 11m 10s |
| 5 | 1 hour | 1h 11m 10s |
After 5 failed attempts, the webhook delivery is marked as failed and:
* The webhook delivery is moved to a dead-letter queue
* For **personal webhooks**, the webhook owner receives an email notification about the failure
* For **workspace webhooks**, all workspace administrators receive an email notification about the failure
* Email notifications are rate-limited to **1 per hour per webhook endpoint** to prevent spam
### Failure Scenarios
A webhook delivery fails and triggers a retry if:
* Your endpoint returns a non-2xx HTTP status code
* Your endpoint doesn't respond within 30 seconds
* A network error occurs during delivery
A webhook delivery is **skipped** (no retries) if:
* The webhook endpoint has been deleted
* The webhook endpoint is disabled/inactive
## Testing Webhooks
You can send a test webhook to verify your endpoint is working correctly:
1. Go to **Settings → Integrations → Webhooks**
2. Find the webhook you want to test
3. Click the **Test** button
4. Check your endpoint to confirm it received the test payload
Test webhooks:
* Send a realistic mock payload with sample meeting data
* Use the same retry and delivery mechanism as real webhooks
* Require the webhook to be **enabled/active**
* Count toward rate limits and retry attempts
Use test webhooks during development to verify your signature verification and payload processing logic before going live.
# Getting Started
Source: https://docs.meetjamie.ai/developers/webhooks/getting-started
All you need to know to get started
### Prerequisites
Before setting up a webhook, you'll need:
1. **An HTTPS endpoint** - Your webhook receiver must use HTTPS (HTTP is not supported for security reasons)
2. **Workspace membership** - Any workspace member can create personal webhooks. Workspace admin access is required to create workspace-wide webhooks.
3. **An eligible plan** - Upgrade to Plus or higher to access webhooks
### Creating a Webhook
1. Navigate to **Settings → Integrations → Webhooks**
2. Click **Create Webhook**
3. Fill in the required information:
* **URL**: Your HTTPS endpoint that will receive webhook events (e.g., `https://api.example.com/webhooks/jamie`)
* **Description** (optional): A note to help you identify this webhook
* **Events**: Select which events should trigger this webhook (currently only `meeting.completed`)
4. **Choose the webhook scope:**
* **Personal webhook** — Triggers only for your own meetings. Available to all workspace members.
* **Workspace webhook** — Triggers for all meetings in the workspace. Requires admin access.
5. **Choose your authentication method:**
The simplest way to authenticate webhooks. Jamie will send a static API key in a header of your choice.
* **Header Name**: Choose a custom header name (e.g., `x-jamie-api-key`, `x-make-apikey`, `Authorization`)
* Leave empty to use the default `x-jamie-api-key`
To verify requests, simply compare the header value with your stored secret. See [Security & Verification](/developers/webhooks/security-verification) for more implementation details.
For maximum security, Jamie signs each request with HMAC-SHA256. This verifies both authenticity and payload integrity.
The signature is sent in the `x-jamie-signature` header. See [Security & Verification](/developers/webhooks/security-verification) for implementation details.
6. Click **Create**
7. **Save your secret key** - This is displayed only once. Store it securely (e.g., in your environment variables or secrets manager).
Once you close the webhook creation dialog, you won't be able to see the secret key again. If you lose it, you'll need to regenerate it from the webhook settings.
## Events
Jamie currently supports the following webhook event:
### `meeting.completed`
Triggered when a meeting has been fully processed and is ready with:
* Meeting summary (in Markdown and HTML formats)
* Full transcript
* Extracted action items/tasks
* Participant information
* Meeting metadata
**Workspace webhooks** are triggered by all meetings of every user in the workspace. **Personal webhooks** are triggered only by the creator's own meetings. If you need to receive webhooks for only your meetings, use a personal webhook instead of filtering on the receiving end.
## Payload Structure
When a webhook event is triggered, Jamie sends a POST request to your endpoint with the following structure:
### Headers
Depending on your chosen authentication method, you'll receive different headers:
**API Key Authentication:**
```text theme={null}
Content-Type: application/json
user-agent: Jamie-Webhooks/1.0
x-jamie-api-key: sk_a1b2c3d4e5f6... (or your custom header name)
jamie-event: meeting.completed
jamie-delivery: 7893456789012345678
```
**Signature Verification:**
```text theme={null}
Content-Type: application/json
user-agent: Jamie-Webhooks/1.0
x-jamie-signature: t=1234567890,v0=5f3d8a7b2c1e9f4a6b8c0d2e4f6a8b0c
jamie-event: meeting.completed
jamie-delivery: 7893456789012345678
```
| Header | Description |
| :------------------ | :----------------------------------------------------------------------------------------------------------------------------------- |
| `x-jamie-api-key` | Your API key for simple authentication (or your custom header name) |
| `x-jamie-signature` | HMAC-SHA256 signature for verifying webhook authenticity (see [Security & Verification](/developers/webhooks/security-verification)) |
| `jamie-event` | The event type that triggered this webhook |
| `jamie-delivery` | Unique identifier for this webhook delivery |
### Request Body
```json theme={null}
{
"metadata": {
"id": "7893456789012345678",
"event": "meeting.completed",
"created": 1701234567
},
"data": {
"title": "Q4 Planning Meeting",
"startTime": "2024-11-27T14:00:00.000Z",
"endTime": "2024-11-27T15:00:00.000Z",
"user": {
"id": "user-456",
"email": "sarah.johnson@example.com"
},
"summary": {
"markdown": "# Meeting Summary\n\n## Key Discussion Points\n• Reviewed Q4 roadmap...",
"html": "Meeting Summary
Key Discussion Points
",
"short": "Q4 product planning meeting covering roadmap, mobile redesign, and user research budget allocation."
},
"transcript": [
{
"speakerId": "1",
"speakerName": "Sarah Johnson",
"text": "Hi everyone! Thanks for joining today's meeting."
},
{
"speakerId": "2",
"speakerName": "Alex Chen",
"text": "Thanks for having me. Let's dive into the agenda."
}
],
"participants": [
{
"id": "1",
"name": "Sarah Johnson",
"email": "sarah.johnson@example.com"
},
{
"id": "2",
"name": "Alex Chen",
"email": "alex.chen@example.com"
}
],
"event": {
"id": "calendar-event-123",
"externalId": "AAMkAGI1AAAt9AHjAAA=",
"title": "Q4 Planning Meeting",
"scheduledTime": "2024-11-27T14:00:00.000Z",
"endTime": "2024-11-27T15:00:00.000Z",
"attendees": [
{
"name": "Sarah Johnson",
"email": "sarah.johnson@example.com",
"responseStatus": "accepted",
"organizer": true
},
{
"name": "Alex Chen",
"email": "alex.chen@example.com",
"responseStatus": "accepted",
"organizer": false
},
{
"name": "Jamie Martinez",
"email": "jamie.martinez@example.com",
"responseStatus": "tentative",
"organizer": false
}
]
},
"tasks": [
{
"content": "Finalize technical specifications for mobile app redesign",
"completed": false,
"assignee": {
"name": "Alex Chen",
"email": "alex.chen@example.com"
}
},
{
"content": "Schedule follow-up meeting for next week",
"completed": false,
"assignee": null
}
],
"tags": [
{
"name": "Product",
"color": "#4A90D9"
},
{
"name": "Planning",
"color": "#50C878"
}
]
}
}
```
### Field Descriptions
#### `metadata`
* `id` (string): Unique identifier for this webhook delivery
* `event` (string): The event type (`meeting.completed`)
* `created` (number): Unix timestamp (seconds) when the webhook was created
#### `data` (top-level)
* `title` (string): Meeting title
* `startTime` (string): ISO 8601 formatted start time of the meeting
* `endTime` (string | null): ISO 8601 formatted end time of the meeting (if available)
#### `data.user`
The Jamie user who recorded the meeting:
* `id` (string): Unique identifier for the user
* `email` (string): Email address of the user
#### `data.summary`
* `markdown` (string): Meeting summary formatted as Markdown with speaker names highlighted
* `html` (string): Meeting summary formatted as HTML, ready to display
* `short` (string): A brief one-line summary of the meeting
#### `data.transcript`
Array of transcript segments:
* `speakerId` (string): Unique identifier for the speaker
* `speakerName` (string): Display name of the speaker
* `text` (string): The spoken text
#### `data.participants`
Array of meeting participants detected in the transcript (people who spoke):
* `id` (string): Unique identifier for the participant
* `name` (string): Display name of the participant
* `email` (string | null): Email address of the participant (if available)
#### `data.event`
Calendar event information (if the meeting is linked to a calendar event):
* `id` (string | null): Internal Jamie calendar event ID (if available)
* `externalId` (string | null): The calendar provider's event ID (e.g., Microsoft Graph API event ID or Google Calendar event ID). Use this to match against events in your own calendar system.
* `title` (string): Calendar event title (falls back to meeting title if no calendar event is linked)
* `scheduledTime` (string): ISO 8601 formatted start time
* `endTime` (string | null): ISO 8601 formatted end time (if available)
* `attendees` (array): List of people invited to the calendar event (empty if no calendar event is linked)
* `name` (string): Name of the attendee
* `email` (string): Email address of the attendee
* `responseStatus` (string | null): RSVP status — one of `needsAction`, `declined`, `tentative`, or `accepted`
* `organizer` (boolean): Whether this attendee is the organizer of the event
**Participants vs. Attendees:** `participants` are people who actually **spoke** during the meeting (detected from the transcript). `attendees` are people who were **invited** to the calendar event — they may or may not have attended or spoken.
#### `data.tasks`
Array of action items extracted from the meeting:
* `content` (string): The task description
* `completed` (boolean): Whether the task is marked as completed
* `assignee` (object | null): The person assigned to this task (if any)
* `name` (string | null): Name of the assignee
* `email` (string | null): Email address of the assignee (if available)
#### `data.tags`
Array of tags (labels) applied to the meeting:
* `name` (string): The tag name
* `color` (string): The tag color as a hex string (e.g., `#4A90D9`)
# Managing Webhooks
Source: https://docs.meetjamie.ai/developers/webhooks/maintenance
Change webhooks to your needs
### Updating a Webhook
1. Navigate to **Settings → Integrations → Webhooks**
2. Click the webhook you want to edit
3. Update the URL, description, or toggle the active status
4. Click **Save**
You can update:
* **URL**: Change where webhook events are delivered
* **Description**: Update the identifying note
* **Active Status**: Enable or disable webhook delivery without deleting the endpoint
You cannot update the selected events after creation. If you need different events, create a new webhook endpoint.
### Regenerating the Signing Secret
If your signing secret is compromised or lost:
1. Navigate to **Settings → Integrations → Webhooks**
2. Click the webhook
3. Click **Regenerate Secret**
4. Save the new secret immediately - it will only be shown once
5. Update your webhook receiver with the new secret
Regenerating the signing secret immediately invalidates the old one. Any webhooks using the old secret will fail verification. Update your receiving endpoint before regenerating.
### Deleting a Webhook
1. Navigate to **Settings → Integrations → Webhooks**
2. Click the webhook you want to delete
3. Click **Delete**
4. Confirm the deletion
Once deleted:
* The webhook stops receiving events immediately
* Any pending deliveries for this webhook are cancelled
* The signing secret is permanently invalidated
* This action cannot be undone
# Make.com Integration
Source: https://docs.meetjamie.ai/developers/webhooks/make-com-integration
Step-by-step guide to integrate Jamie webhooks with Make.com
This guide walks you through setting up a Jamie webhook that sends meeting summaries to [Make.com](https://make.com) for automation.
### Prerequisites
* A Jamie account with Plus plan or higher
* A Make.com account
* Workspace membership in Jamie (admin access required only for workspace-wide webhooks)
### Step 1: Create the Webhook in Jamie First
We'll create the Jamie webhook first to get the API key, then use it when setting up Make.com.
1. Go to **Settings → Integrations → Webhooks** in Jamie
2. Click **Create Webhook**
3. Enter a placeholder URL for now (e.g., `https://hook.make.com/placeholder`)
4. Add a description (e.g., "Make.com automation")
5. Click **Continue**
6. Select **API Key** as the authentication method
7. Set the **Header Name** to: `x-make-apikey`
8. Click **Create Webhook**
9. **Copy the generated secret key** (`sk_...`) - you'll need this for Make.com
Save this key somewhere safe! You won't be able to see it again.
### Step 2: Create the Webhook in Make.com
Now create the Make.com webhook with API key verification built-in:
1. Log in to your Make.com account
2. Create a new scenario or open an existing one
3. Click **+** to add a new module
4. Search for **Webhooks** and select **Custom webhook**
5. Click **Add** to create a new webhook
6. Enter a **Webhook name** (e.g., "Jamie webhook")
7. Expand **API Key authentication** → **API keys**
8. Click **+ Add API key**
9. Click **Add** next to the "Choose a key" dropdown
10. In the **Add new keychain** dialog:
* **Name**: Enter a name (e.g., "Jamie API Key")
* **API key value**: Paste the secret key (`sk_...`) from Jamie
11. Click **Create**
12. Select the key you just created from the dropdown
13. Click **Save**
14. **Copy the webhook URL** that Make.com generates
The URL will look something like: `https://hook.make.com/abc123xyz789...`
Make.com will now automatically reject any requests that don't include the correct `x-make-apikey` header with your secret key.
### Step 3: Update the Jamie Webhook URL
1. Go back to Jamie **Settings → Integrations → Webhooks**
2. Find your webhook and click to edit it
3. Replace the placeholder URL with the real Make.com webhook URL you copied
4. Click **Save**
### Step 4: Determine the Data Structure
1. In Make.com, right-click on your webhook module and select **Run this module only**
2. Go to Jamie and click **Send Test Webhook** for your webhook
3. Make.com will capture the test data and show you the available fields
4. Click **OK** to save the structure
This step is important! Make.com needs to "learn" the data structure before you can map fields to other modules.
### Step 5: Build Your Automation
Now you can use the meeting data in your Make.com scenario! Here are some common examples:
#### Send Summary to Slack
```
Webhook → Slack: Create a Message
```
Map the fields:
* **Channel**: Select your channel (e.g., `#meeting-summaries`)
* **Text**: Click and select `data` → `summary` → `markdown`
#### Save to Google Docs
```
Webhook → Google Docs: Create a Document
```
Map the fields:
* **Title**: `{{data.event.title}} - Meeting Summary`
* **Content**: Select `data` → `summary` → `html`
#### Add Tasks to Notion
```
Webhook → Iterator → Notion: Create a Database Item
```
1. Add an **Iterator** module after the webhook
2. Set the array to: `data` → `tasks`
3. Connect to Notion and map:
* **Task name**: `content` (from the iterator)
* **Status**: `To Do`
### Example: Complete Automation Flow
```
Jamie Webhook
↓
Slack: Post summary to #meetings
↓
Iterator: Loop through tasks
↓
Notion: Create task items
↓
Google Calendar: Create follow-up event
```
### Webhook Data Available in Make.com
After the webhook receives data, you'll have access to these fields:
| Field Path | Description | Example |
| :------------------------- | :--------------------------- | :------------------------------ |
| `metadata.id` | Webhook delivery ID | `"7893456789012345678"` |
| `metadata.event` | Event type | `"meeting.completed"` |
| `data.event.title` | Meeting title | `"Q4 Planning Meeting"` |
| `data.event.scheduledTime` | Start time (ISO 8601) | `"2024-11-27T14:00:00.000Z"` |
| `data.event.endTime` | End time (ISO 8601) | `"2024-11-27T15:00:00.000Z"` |
| `data.summary.markdown` | Summary in Markdown | `"# Meeting Summary..."` |
| `data.summary.html` | Summary in HTML | `"Meeting Summary
..."` |
| `data.transcript[]` | Array of transcript segments | See below |
| `data.participants[]` | Array of participants | `[{ id, name }]` |
| `data.tasks[]` | Array of action items | `[{ content, completed }]` |
#### Transcript Structure
Each item in `data.transcript[]`:
* `speakerId`: Unique speaker identifier
* `speakerName`: Display name
* `text`: What was said
#### Tasks Structure
Each item in `data.tasks[]`:
* `content`: The task description
* `completed`: Boolean (usually `false` for new tasks)
### Troubleshooting
**Webhook not receiving data:**
* Ensure the webhook is enabled in Jamie (check the toggle)
* Verify the Make.com URL is correct (no extra spaces)
* Check that your Jamie plan supports webhooks
* Make sure the Make.com scenario is **turned on** (not just saved)
**Authentication failing (401 error):**
* Verify the API key in Make.com matches exactly the key from Jamie
* Check that the header name in Jamie is set to `x-make-apikey`
* Try regenerating the key in Jamie and updating it in Make.com
**"No data" in Make.com:**
* Run the webhook module in "Run once" mode first
* Send a test webhook from Jamie to capture the structure
* Check the Make.com **History** tab for incoming requests
**Fields not mapping correctly:**
* Re-run the "determine data structure" step
* Make sure you're selecting fields from the correct module
* Check that array fields use an Iterator module
**Scenario not running automatically:**
* Verify the scenario is **turned on** (toggle in bottom-left)
* Check your Make.com plan limits (operations per month)
* Look for errors in the scenario's execution history
Use Make.com's **History** tab to inspect incoming webhook payloads and debug any issues. You can see the full request including headers and body.
# Security & Verification
Source: https://docs.meetjamie.ai/developers/webhooks/security-verification
How to set up security
Jamie offers two authentication methods for webhooks. Choose the one that best fits your needs.
## Authentication Methods
### API Key (Recommended)
The simplest way to verify webhook requests. Jamie sends a static API key in a header that you specify during webhook creation.
**How it works:**
1. When creating the webhook, choose "API Key" authentication
2. Optionally specify a custom header name (default: `x-jamie-api-key`)
3. Save the generated secret key (`sk_...`)
4. In your webhook handler, compare the header value with your stored secret
#### Verification Code Examples
```javascript theme={null}
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhooks/jamie', (req, res) => {
// Get the API key from header (use your custom header name if configured)
const apiKey = req.headers['x-jamie-api-key'];
// Compare with your stored secret
if (apiKey !== process.env.JAMIE_WEBHOOK_SECRET) {
console.error('Invalid API key');
return res.status(401).send('Unauthorized');
}
// API key is valid, process the webhook
const { data } = req.body;
console.log('Meeting completed:', data.event.title);
console.log('Summary:', data.summary.markdown);
// Process tasks
data.tasks.forEach(task => {
console.log('Task:', task.content);
});
res.status(200).send('OK');
});
app.listen(3000, () => {
console.log('Webhook server running on port 3000');
});
```
```python theme={null}
import os
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/webhooks/jamie', methods=['POST'])
def handle_webhook():
# Get the API key from header (use your custom header name if configured)
api_key = request.headers.get('x-jamie-api-key')
# Compare with your stored secret
if api_key != os.environ.get('JAMIE_WEBHOOK_SECRET'):
print('Invalid API key')
return 'Unauthorized', 401
# API key is valid, process the webhook
data = request.get_json()
print('Meeting completed:', data['data']['event']['title'])
print('Summary:', data['data']['summary']['markdown'])
# Process tasks
for task in data['data']['tasks']:
print('Task:', task['content'])
return 'OK', 200
if __name__ == '__main__':
app.run(port=3000)
```
```go theme={null}
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
)
type WebhookPayload struct {
Data struct {
Event struct {
Title string `json:"title"`
} `json:"event"`
Summary struct {
Markdown string `json:"markdown"`
} `json:"summary"`
Tasks []struct {
Content string `json:"content"`
} `json:"tasks"`
} `json:"data"`
}
func webhookHandler(w http.ResponseWriter, r *http.Request) {
// Get the API key from header (use your custom header name if configured)
apiKey := r.Header.Get("x-jamie-api-key")
// Compare with your stored secret
if apiKey != os.Getenv("JAMIE_WEBHOOK_SECRET") {
fmt.Println("Invalid API key")
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
// API key is valid, process the webhook
body, _ := io.ReadAll(r.Body)
var payload WebhookPayload
json.Unmarshal(body, &payload)
fmt.Println("Meeting completed:", payload.Data.Event.Title)
fmt.Println("Summary:", payload.Data.Summary.Markdown)
// Process tasks
for _, task := range payload.Data.Tasks {
fmt.Println("Task:", task.Content)
}
w.WriteHeader(http.StatusOK)
}
func main() {
http.HandleFunc("/webhooks/jamie", webhookHandler)
fmt.Println("Webhook server running on port 3000")
http.ListenAndServe(":3000", nil)
}
```
### Signature Verification (Advanced)
For maximum security, Jamie can sign all webhook requests using HMAC-SHA256. This ensures requests are authentic **and** haven't been tampered with.
#### Signature Format
The `x-jamie-signature` header uses the following format:
```
t=,v0=
```
* `t`: Unix timestamp (seconds) when the signature was created
* `v0`: HMAC-SHA256 signature of the payload
#### Verification Steps
1. **Extract the timestamp and signature** from the `x-jamie-signature` header
2. **Validate the timestamp** - Reject requests with timestamps older than 5 minutes (300 seconds) to prevent replay attacks
3. **Recreate the signed message** - Concatenate the timestamp, a period (`.`), and the raw request body: `{timestamp}.{raw_body}`
4. **Compute the expected signature** - Generate an HMAC-SHA256 hash of the message using your signing secret
5. **Compare signatures** - Use a constant-time comparison to prevent timing attacks
#### Verification Code Examples
```javascript theme={null}
const crypto = require('crypto');
async function verifyWebhookSignature(
payload: string,
signature: string,
secret: string
): Promise {
// Parse signature header: t=timestamp,v0=hash
const parts = signature.split(',');
const timestamp = parts[0].split('=')[1];
const expectedSignature = parts[1].split('=')[1];
// Validate timestamp (prevent replay attacks - 5 min tolerance)
const now = Math.floor(Date.now() / 1000);
if (now - parseInt(timestamp) > 300) {
throw new Error('Signature expired');
}
// Recreate the signed message
const message = `${timestamp}.${payload}`;
// Generate HMAC signature
const hmac = crypto.createHmac('sha256', secret);
hmac.update(message);
const actualSignature = hmac.digest('hex');
// Compare signatures using constant-time comparison
const expectedBuffer = Buffer.from(expectedSignature, 'hex');
const actualBuffer = Buffer.from(actualSignature, 'hex');
if (!crypto.timingSafeEqual(expectedBuffer, actualBuffer)) {
throw new Error('Invalid signature');
}
return true;
}
// Usage in your webhook endpoint (Express example):
app.post('/webhooks/jamie', async (req, res) => {
const signature = req.headers['x-jamie-signature'];
const payload = JSON.stringify(req.body);
try {
await verifyWebhookSignature(
payload,
signature,
process.env.JAMIE_WEBHOOK_SECRET
);
// Signature is valid, process the webhook
const { data } = req.body;
console.log('Meeting completed:', data.event.title);
res.status(200).send('OK');
} catch (error) {
console.error('Webhook verification failed:', error);
res.status(401).send('Unauthorized');
}
});
```
```python theme={null}
import hmac
import hashlib
import time
import json
from typing import Dict
def verify_webhook_signature(
payload: str,
signature: str,
secret: str
) -> bool:
"""Verify Jamie webhook signature
Args:
payload: The raw request body as a string
signature: The x-jamie-signature header value
secret: Your webhook signing secret
Returns:
True if signature is valid
Raises:
ValueError: If signature is invalid or expired
"""
# Parse signature header: t=timestamp,v0=hash
parts: Dict[str, str] = {
p.split('=')[0]: p.split('=')[1]
for p in signature.split(',')
}
timestamp: int = int(parts['t'])
expected_signature: str = parts['v0']
# Validate timestamp (prevent replay attacks - 5 min tolerance)
now: int = int(time.time())
if now - timestamp > 300:
raise ValueError('Signature expired')
# Recreate the signed message
message: str = f"{timestamp}.{payload}"
# Generate HMAC signature
signature_bytes: str = hmac.new(
secret.encode('utf-8'),
message.encode('utf-8'),
hashlib.sha256
).hexdigest()
# Compare signatures (constant-time comparison)
if not hmac.compare_digest(signature_bytes, expected_signature):
raise ValueError('Invalid signature')
return True
# Usage in your webhook endpoint (Flask example):
from flask import Flask, request
app = Flask(__name__)
@app.route('/webhooks/jamie', methods=['POST'])
def handle_webhook():
signature: str = request.headers.get('x-jamie-signature')
payload: str = request.get_data(as_text=True)
try:
verify_webhook_signature(
payload,
signature,
os.environ['JAMIE_WEBHOOK_SECRET']
)
# Signature is valid, process the webhook
data: Dict = json.loads(payload)
print('Meeting completed:', data['data']['event']['title'])
return 'OK', 200
except Exception as e:
print('Webhook verification failed:', str(e))
return 'Unauthorized', 401
```
```go theme={null}
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strconv"
"strings"
"time"
)
// verifyWebhookSignature verifies the Jamie webhook signature
func verifyWebhookSignature(payload, signature, secret string) error {
// Parse signature header: t=timestamp,v0=hash
parts := make(map[string]string)
for _, part := range strings.Split(signature, ",") {
kv := strings.SplitN(part, "=", 2)
if len(kv) == 2 {
parts[kv[0]] = kv[1]
}
}
timestamp, err := strconv.ParseInt(parts["t"], 10, 64)
if err != nil {
return fmt.Errorf("invalid timestamp: %w", err)
}
expectedSignature := parts["v0"]
// Validate timestamp (prevent replay attacks - 5 min tolerance)
now := time.Now().Unix()
if now-timestamp > 300 {
return fmt.Errorf("signature expired")
}
// Recreate the signed message
message := fmt.Sprintf("%d.%s", timestamp, payload)
// Generate HMAC signature
h := hmac.New(sha256.New, []byte(secret))
h.Write([]byte(message))
actualSignature := hex.EncodeToString(h.Sum(nil))
// Compare signatures (constant-time comparison)
if !hmac.Equal([]byte(actualSignature), []byte(expectedSignature)) {
return fmt.Errorf("invalid signature")
}
return nil
}
// WebhookPayload represents the structure of Jamie webhook data
type WebhookPayload struct {
Metadata struct {
ID string `json:"id"`
Event string `json:"event"`
Created int64 `json:"created"`
} `json:"metadata"`
Data struct {
Event struct {
Title string `json:"title"`
} `json:"event"`
} `json:"data"`
}
// webhookHandler handles incoming webhooks from Jamie
func webhookHandler(w http.ResponseWriter, r *http.Request) {
signature := r.Header.Get("x-jamie-signature")
body, err := io.ReadAll(r.Body)
if err != nil {
http.Error(w, "Failed to read body", http.StatusBadRequest)
return
}
secret := os.Getenv("JAMIE_WEBHOOK_SECRET")
if err := verifyWebhookSignature(
string(body),
signature,
secret,
); err != nil {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
// Signature is valid, process the webhook
var payload WebhookPayload
if err := json.Unmarshal(body, &payload); err != nil {
http.Error(w, "Invalid JSON", http.StatusBadRequest)
return
}
fmt.Printf("Meeting completed: %s\n", payload.Data.Event.Title)
w.WriteHeader(http.StatusOK)
}
func main() {
http.HandleFunc("/webhooks/jamie", webhookHandler)
http.ListenAndServe(":8080", nil)
}
```
**Security Best Practices:**
* Always verify the API key or signature before processing webhook data
* For signature verification, use constant-time comparison to prevent timing attacks
* Validate timestamps to prevent replay attacks (recommended tolerance: 5 minutes)
* Store your secret key securely (use environment variables or a secrets manager)
* Never commit secret keys to version control
# Troubleshooting
Source: https://docs.meetjamie.ai/developers/webhooks/troubleshooting
Guidelines to troubleshoot
### Webhook deliveries are failing
**Check your endpoint:**
* Ensure it's accessible from the internet (not localhost or behind a firewall)
* Verify it uses HTTPS (HTTP is not supported)
* Confirm it returns a 2xx status code
* Make sure it responds within 30 seconds
**Check your signature verification:**
* Ensure you're using the correct signing secret
* Verify you're comparing the raw request body (not parsed JSON)
* Check that timestamp validation isn't too strict (recommended: 5 minutes)
**Check the webhook status:**
* Ensure the webhook is enabled/active
* Verify you haven't exceeded the webhook limit (3 personal webhooks per user, or 5 workspace webhooks per workspace)
### Not receiving webhooks
**Verify the webhook configuration:**
* Check that the webhook is enabled/active
* Confirm the URL is correct
* Ensure you've selected the `meeting.completed` event
**Check your plan:**
* Webhooks require Plus, Pro, Team, or Enterprise plans
* Free plans don't have access to webhooks
**Verify meetings are completing:**
* Webhooks only fire when meetings are fully processed
* Check that meetings are being recorded and processed successfully
**Check webhook scope:**
* **Personal webhooks** only fire for the creator's own meetings — they won't trigger for other users' meetings
* **Workspace webhooks** fire for all meetings in the workspace
### Receiving duplicate webhooks
This is expected behavior and your endpoint should be **idempotent**:
* Use the `metadata.id` field to track which deliveries you've processed
* If you receive the same `metadata.id` twice, skip processing the duplicate
Duplicates can occur due to:
* Retries after temporary failures
* Network issues causing multiple delivery attempts
# Overview
Source: https://docs.meetjamie.ai/developers/webhooks/webhooks
Set up webhooks to customize your workflow with Jamie
## Overview
Webhooks allow you to receive real-time notifications when events occur in Jamie. When a meeting is completed and processed, Jamie can automatically send the meeting data (summary, transcript, tasks, and more) to your specified endpoint.
This enables you to:
* **Integrate meeting data into your systems** - Automatically sync meeting summaries to your CRM, project management tools, or internal databases
* **Build custom workflows** - Trigger actions based on meeting completions, such as creating tickets, sending notifications, or updating records
* **Maintain data consistency** - Keep your systems up-to-date with the latest meeting information without manual exports
## Availability
Webhooks are available on the following plans:
* **Pro**
* **Team**
* **Enterprise**
Jamie supports two types of webhooks:
* **Personal webhooks** — Created by any workspace member. They only trigger for the creator's own meetings. Each user can create up to **3 personal webhooks**.
* **Workspace webhooks** — Created by workspace admins. They trigger for all meetings across the workspace. Each workspace can have up to **5 workspace webhooks**.
All workspace members can access the Developers page to manage their personal webhooks. Only admins can create and manage workspace-wide webhooks.
## Rate Limits
* **Maximum personal webhooks per user**: 3
* **Maximum workspace webhooks per workspace**: 5
* **Failure notification emails**: 1 per hour per webhook endpoint
* **Webhook timeout**: 30 seconds
* **Maximum retries**: 5 attempts
## Support
If you're experiencing issues with webhooks:
1. Check the [Troubleshooting](/developers/webhooks/troubleshooting) section
2. Review webhook delivery logs in your Jamie workspace
3. Contact support with your webhook endpoint ID and delivery ID for assistance
For feature requests or feedback about webhooks, please reach out to our support team.
# Firewall Ports
Source: https://docs.meetjamie.ai/enterprise/admins/firewall-ports
The endpoints and ports the Jamie desktop app needs to reach.
All Jamie connections are **outbound only** (client → server) over **port 443/TCP**. No inbound rules and no UDP are required.
**Minimal configuration:** allowlisting `*.meetjamie.ai` plus `turn.cloudflare.com` covers the core services. The remaining endpoints depend on which login method, calendar, and integrations you use.
## Core services
Required for Jamie to work.
| Endpoint | Protocol | Purpose |
| --------------------- | --------- | ----------------------------------- |
| `app.meetjamie.ai` | HTTPS/WSS | Web application & API |
| `api.meetjamie.ai` | HTTPS/WSS | Backend API |
| `turn.meetjamie.ai` | TLS | WebRTC audio streaming (TURN relay) |
| `turn.cloudflare.com` | TLS | TURN fallback |
## Authentication
Depending on your login method.
| Endpoint | Protocol | Purpose |
| --------------------------- | -------- | ------------------------- |
| `appleid.apple.com` | HTTPS | Apple Sign-In |
| `accounts.google.com` | HTTPS | Google Sign-In |
| `oauth2.googleapis.com` | HTTPS | Google OAuth token |
| `login.microsoftonline.com` | HTTPS | Microsoft / Entra Sign-In |
## Calendar integration
Optional — only needed if you connect a calendar.
| Endpoint | Protocol | Purpose |
| --------------------- | -------- | ----------------------------- |
| `graph.microsoft.com` | HTTPS | Microsoft Calendar & Contacts |
| `www.googleapis.com` | HTTPS | Google Calendar API |
## Telemetry & updates
| Endpoint | Protocol | Purpose |
| ----------------------- | -------- | ------------------- |
| `eu.i.posthog.com` | HTTPS | Analytics (EU) |
| `*.ingest.de.sentry.io` | HTTPS | Error tracking (EU) |
| `api.github.com` | HTTPS | Update check |
| `github.com` | HTTPS | Update download |
## Notes
* Only outbound connections on port 443/TCP.
* No UDP required (TURN-over-TLS).
* Minimal configuration: `*.meetjamie.ai` + `turn.cloudflare.com`.
# Integrations & Developers
Source: https://docs.meetjamie.ai/enterprise/admins/integrations-and-developers
Connect Jamie to the tools your team already uses — CRMs, docs, and task tools — and build on top of it with the API, webhooks, and MCP.
**What's available:**
* **CRM:** HubSpot, Salesforce, Attio (log meetings to contacts, companies, deals, accounts) — plus DealCloud and Affinity for deal teams.
* **Note-taking:** Notion, Google Docs, OneNote.
* **Task management:** Asana (turn action items into tasks).
**Connecting one:**
Go to **Settings → Integrations**.
Pick the integration → click **Connect** → complete the authorization flow → set your preferences.
**Two ways to send meetings:**
* **Manual:** click **Share** on a meeting → **Integrations** tab → choose where to send it.
* **Automatic sync:** turn on auto-sync in the integration's settings to push every new meeting automatically.
**Choose what syncs:** Summary (AI notes), Transcript (full word-for-word), and Tasks (action items). Not every integration supports all three — check the individual integration page.
**Managing them:** in **Settings → Integrations** you can see connection status, configure what content syncs, and disconnect any integration.
**Need a custom workflow?** If you need an integration or automation that isn't listed (CRM mapping, an internal system, a specific data flow), reach out to your Account Executive.
## API, Webhooks & MCP
For teams that want to build on top of Jamie, there are three developer surfaces.
Programmatic access to your meeting data (summaries, transcripts, tasks, tags).
* Create a key in **Settings → Developers → API Keys**, then authenticate with a single `x-api-key` header — no OAuth, no token refresh.
* Two key types: **workspace keys** (`/v1/workspace/…` — all workspace meetings/tasks) and **personal keys** (`/v1/me/…` — your own + shared meetings, plus search and tags).
* Base URL: `https://beta-api.meetjamie.ai`. Use the built-in **Request Builder** to construct calls visually.
Get notified automatically when events happen (e.g. a meeting finishes processing), so you can trigger downstream workflows instead of polling. Includes delivery/retry handling, signature verification for security, and a ready-made Make.com guide. Set them up in the developer settings.
Connect AI tools (Claude, ChatGPT, Cursor, Windsurf, or your own) directly to your meeting notes so they can search meetings, pull summaries, and extract action items.
* Server URL: `https://mcp.meetjamie.ai/mcp` (Streamable HTTP + browser-based OAuth; no API keys or client secrets needed).
* Available tools: `list_meetings`, `get_meeting`, `search_meetings`, `list_tasks`, `create_tasks`, `list_tags`, `list_templates`, `upsert_template`.
* **Admin note:** on Claude Team/Enterprise, an Owner must first add the connector in **Organization settings → Connectors** before members can enable it.
Browse all available integrations.
API, webhooks, and MCP reference.
# Intune MSI Deployment Guide
Source: https://docs.meetjamie.ai/enterprise/admins/intune-deployment-guide
Deploy Jamie as a per-machine Line-of-Business MSI app through Microsoft Intune.
## Overview
Jamie is deployed as a **Line-of-Business (LOB) MSI app** via Microsoft Intune. The MSI performs a **per-machine installation** (`InstallScope="perMachine"`), installing into `C:\Program Files\Jamie` for all users on the device.
Jamie includes a built-in auto-updater (`JamieUpdaterService`), so Intune should only handle the initial deployment — not ongoing version management.
## Download
Jamie\_5.6.52\_x64\_en-US.msi
The MSI supports **x64** and **ARM64** architectures. 32-bit (x86) builds are not supported.
## Adding the app in Intune
Navigate to **Microsoft Intune admin center → Apps → All apps → Add**.
Choose **Line-of-business app**.
Upload the `.msi` file.
### App information
| Setting | Value |
| ---------------------- | -------------------------------------- |
| Name | Jamie |
| Publisher | Jamie (Wespond UG) |
| App Install Context | Device (pre-selected, per-machine MSI) |
| **Ignore app version** | **Yes** |
| Command-line arguments | `/qn` |
### Ignore app version — why this matters
The **Ignore app version** setting must be set to **Yes**. You'll find it in the **App information** pane when configuring the LOB app.
Jamie ships with a built-in update service (`JamieUpdaterService`) that automatically updates the application in the background. If **Ignore app version** is left at **No** (the default), Intune enforces the originally deployed MSI version, which creates a race condition:
Setting **Ignore app version = Yes** tells Intune to only verify that Jamie is installed, without enforcing a specific version. This is the Microsoft-recommended approach for MSI apps with self-updating installers.
## What the MSI installs
| Component | Location / Details |
| ------------------------------ | ---------------------------------------------------------------------------- |
| Main executables and resources | `C:\Program Files\Jamie\*` |
| Registry | `HKLM\Software\Jamie (Wespond UG)\Jamie` — stores `InstallDir` and `Version` |
| Deep link protocol | `jamie://` (registered in `HKLM\Software\Classes`) |
| Shortcuts | Desktop + Start Menu |
**MSI UpgradeCode:** `7f2a9f62-56a0-4f67-9e14-1c18553b1b60`
## Assignments
Assign the app to the appropriate device groups as **Required** for automatic deployment, or **Available for enrolled devices** if users should install it from Company Portal.
Since this is a per-machine install, target **device groups** rather than user groups for the most predictable behavior.
## Uninstall
The MSI supports standard uninstall via Intune. The `JamieUpdaterService` is automatically stopped and removed on uninstall. All shortcuts, registry entries, and the install directory are cleaned up.
## Notes
* **Do not** use Intune app supersedence with auto-update enabled for Jamie — the built-in updater handles all version management.
* The MSI uses `REINSTALLMODE=amus` and `AllowSameVersionUpgrades="yes"`, so re-deploying the same version is safe and non-destructive.
* The WebView2 runtime is bundled and bootstrapped by the installer if it isn't already present on the device.
# Setup Essentials
Source: https://docs.meetjamie.ai/enterprise/admins/setup-essentials
The core of your rollout — logins, calendar access, activating users, driving adoption, the recording notice, and installing Jamie.
## Single Sign-On (SSO / SAML)
SSO lets your organization manage authentication centrally through your identity provider (IdP). Jamie supports SAML 2.0, compatible with Okta, Microsoft Entra ID, Google Workspace, Auth0, ADP, Cloudflare, and any standard SAML or OIDC provider.
Setup is two steps, in order, both under **Settings → Security** in the Jamie app.
1. Go to **Settings → Security** and click **Configure** next to **Domain Verification Settings**.
2. Enter your domain (e.g. `example.com`).
3. Add the provided TXT record to your DNS (Cloudflare, Route 53, Google Domains, etc.).
4. Verification is automatic — usually under a minute, but up to 48 hours if you're editing an existing TXT record.
Repeat for multiple domains (e.g. a parent and subsidiary).
![Domain verification settings]()
1. Go to **Settings → Security** and click **Configure** next to **SSO-Provider Connection Settings**.
2. Select your IdP and follow the on-screen wizard.
3. You'll get an **ACS URL** and **Entity ID** to enter in your IdP; the wizard has step-by-step instructions per provider.
Supported IdPs: Okta, Microsoft Entra ID (Azure AD), Google Workspace, Auth0, ADP, Cloudflare, Custom SAML (any SAML 2.0 IdP), and Custom OIDC.
![SSO provider selection]()
After setup, anyone signing in with a verified domain is **required** to authenticate through your IdP. Users who previously used email or social login get redirected to SSO on their next login.
**Directory Sync (SCIM)** — available on Enterprise. Automatically create, update, and deprovision users from your IdP under **Settings → Security → Directory Connection Settings**. See [Directory Sync](/enterprise/directory-sync) for setup instructions.
**IP allowlisting** is available on Enterprise. Restrict access to your workspace to approved IP ranges under **Settings → Security → IP Allowlist**. See [IP allowlisting](/enterprise/ip-allowlisting) for setup instructions.
## Calendar permissions
Connecting a calendar is what makes most of Jamie's smart features work: it detects upcoming meetings, sends start-recording reminders, auto-fills meeting titles, improves speaker identification, and it's a hard requirement for the [automated recording notice](#recording-notification) and other upcoming features. Each user connects their own calendar — there is no org-wide calendar connection.
**How users connect** (Settings → Integrations):
* **Google Calendar** — Integrations → Google Calendar → **Connect Google Calendar** → sign in → grant permissions.
* **Outlook** — Integrations → Outlook → **Connect Outlook Calendar** → sign in → grant permissions.
Multiple calendars can be selected and synced individually.
**What you as an admin should know:**
If your org requires admin consent for third-party apps, users will hit an "Approval required" screen. Approve calendar access once for everyone with Jamie's approval link: any Jamie user can copy it from **Settings → Integrations → Outlook Calendar**. Open it as a Microsoft 365 administrator, review the six sign-in and calendar permissions, and accept. After that, users connect without individual approval.
Avoid the generic **Grant admin consent** button in the Entra admin center. It approves every permission registered on the Jamie application, not just the ones the calendar integration uses. See [Outlook calendar](/getting-started/calendar/outlook#for-administrators) for the exact permission list.
Jamie uses the Microsoft Graph API, which only reaches mailboxes hosted in Exchange Online. On-prem or un-migrated hybrid mailboxes will see a "mailbox is hosted on-premise" error. Options are migrating the mailbox to Exchange Online, or exploring Exchange Web Services with support.
**Permissions Jamie requests:**
| Permission | Purpose |
| ----------------------------------------- | -------------------------------------------------- |
| `openid`, `profile`, `email`, `User.Read` | Secure sign-in and basic profile |
| `Calendars.Read` | Detect meetings, reminders, auto-titles |
| `People.Read`, `Contacts.Read` | Speaker identification / Speaker Memory |
| `offline_access` | Keep the calendar synced without repeated sign-ins |
Data stored from the calendar: event details (title, time, location, description, conferencing links), attendee names/emails, and contact info for speaker memory.
`People.Read` / `Contacts.Read` power **Speaker Memory**, which creates voiceprints classed as **biometric data** under GDPR. Jamie can keep this deactivated by default at workspace level on request — the recommended default for most deployments.
## Activating users
How users get access depends on your setup:
* **With SSO:** anyone signing in with a verified domain is automatically routed through your IdP. Control exactly who gets in by assigning users or groups to the Jamie app in your identity provider (Entra ID, Okta, Google Workspace, etc.). Remove them there to revoke access.
* **Calendar approval:** make sure you've granted admin consent (see [Calendar permissions](#calendar-permissions)) so users can connect calendars without hitting an approval wall.
## Driving real adoption
Getting licenses assigned is the easy part — getting people to actually use Jamie is what matters.
What tends to work:
* **Make calendar connection step one.** Most of Jamie's value (reminders, auto-titles, speaker ID) depends on it. Push users to connect on day one.
* **Seed shared templates and tags.** If teams open Jamie and find ready-made formats for their meeting types, they adopt faster than from a blank slate.
* **Tie it to an existing habit** — e.g. "every client call gets a Jamie summary shared in the deal channel."
* **Set up integrations early** (CRM, Notion, Slack) so notes flow into tools people already live in, instead of being one more place to check.
* **Revisit usage after a couple of months** to see how it's going, where there are questions, etc.
Want usage visibility? If you want to know who's actively using Jamie across the org, ask your Account Manager.
## Recording notification
As the customer you are the **data controller**, so you're responsible for the legal basis (typically legitimate interest for routine business meetings) and for informing participants under GDPR Arts. 13 and 14. Jamie gives you several mechanisms to meet that transparency obligation.
**Automated recording notice:**
* Sends attendees an email \~24 hours before each meeting explaining you'll use Jamie.
* Requires a connected calendar.
* Attendees from your own workspace are auto-excluded, and domain exclusion can be configured for internal-only deployments.
* Enable it under **Settings → Notifications → Recording notice**.
![Recording notice settings]()
**Other mechanisms you can combine:**
* A configurable notice inside the calendar invite or in your signature.
* A quick verbal heads-up at the start of the meeting.
## Intune guide
The app your users download from [meetjamie.ai](https://www.meetjamie.ai/) is a **per-user MSI installer** — the right choice for almost every deployment.
* **No admin rights needed.** Each user installs Jamie under their own profile, so it works even in locked-down corporate environments without local admin.
* **Automatic updates.** Jamie updates itself in the background — no admin privileges required.
* **Works with Intune too.** You can distribute the per-user MSI through Intune as a user-context (rather than device-context) assignment if you prefer a managed rollout.
If your organization runs an **application blocker** (e.g. AppLocker), you'll need to allow Jamie to install and update — see [Common deployment issues & troubleshooting](/enterprise/admins/troubleshooting#app-blocker-prevents-installation).
### Need a per-machine installation?
Some enterprises prefer a single **per-machine** installation shared by all users on a device. This option is available on request — reach out to your dedicated **[Account Manager](/enterprise/admins/troubleshooting#your-account-managers)** and we'll provide the per-machine deployment guide.
Hitting installation problems? See [Common deployment issues & troubleshooting](/enterprise/admins/troubleshooting).
# Troubleshooting & Support
Source: https://docs.meetjamie.ai/enterprise/admins/troubleshooting
Fix the most common deployment issues, then find resources, support, and your Account Managers.
## Common deployment issues
Across enterprise rollouts, a handful of issues come up again and again. Getting ahead of these prevents most failed deployments.
### App blocker prevents installation
If your organization uses an application blocker (such as AppLocker), it can stop the Jamie MSI from installing or updating. This is one of the most common blockers we see. To resolve it, your admins should:
* Allow **MSI files to be executed** under your app blocker policy.
* Whitelist **either** of the following:
* the temporary Windows folder where MSIs are downloaded for execution, **or**
* MSI installers signed by **Wespond UG** (Jamie's publisher).
### Proxies must be configured system-wide
If you route traffic through a proxy, make sure it's configured **system-wide on Windows**, not just at the user level. A user-level-only proxy is a frequent misconfiguration that stops Jamie from connecting at all.
### Firewall ports
If Jamie installs but then fails to work, a firewall is the usual cause. Make sure the ports Jamie needs are open.
Reference sheet of the endpoints and ports Jamie needs open.
### Sending an installation log to support
If you hit an issue during deployment, generate an installation log and include it when you contact support — it gives the team something concrete to debug.
Run the installer with logging enabled:
```powershell theme={null}
msiexec /i Jamie_5.7.3_x64_en-US.msi /l*v install.log
```
Adjust the version in the filename (`5.7.3`) to match the MSI you actually downloaded.
This produces an `install.log` file in the current folder. Send it to [support@meetjamie.ai](mailto:support@meetjamie.ai).
## Resources
Step-by-step guides and answers to common questions.
Build on top of Jamie with the API, webhooks, and MCP.
## Support
* **[Help Center](https://docs.meetjamie.ai)** — step-by-step guides and answers to common questions
* **Support** — reach the team directly at [support@meetjamie.ai](mailto:support@meetjamie.ai)
## Your Account Managers
You can always reach out to your Account Manager, who will help you with any questions:
* **Tom** — Account Manager — [tom@meetjamie.ai](mailto:tom@meetjamie.ai)
* **Pleurat** — Account Manager — [pleurat@meetjamie.ai](mailto:pleurat@meetjamie.ai)
# Welcome to Jamie!
Source: https://docs.meetjamie.ai/enterprise/admins/welcome
Your control center for rolling out and managing Jamie across your organization.
## About Jamie
Jamie is your personal AI note taker. It turns any meeting — online, hybrid, or in person — into structured notes, transcripts, and action items, in 100+ languages.
What makes Jamie different:
* **No bot needed.** Jamie doesn't join your call as a visible participant. It captures audio in the background, so nothing interrupts your meeting.
* **Works everywhere.** Online, hybrid, or fully in-person meetings — Jamie takes notes on any platform.
* **Privacy-first.** Hosted in Europe, GDPR-compliant, data encrypted in transit and at rest, data residency in the EU (processing and hosting). Meeting audio is deleted after transcription, and your data is never used to train AI models.
What you get from every meeting:
* **Meeting notes** — clear, human-like summaries.
* **Transcript** — full transcription of the conversation.
* **Action items** — tasks and decisions captured automatically.
It also fits your workflow, syncing notes to tools like Salesforce, HubSpot, OneNote, and Notion.
## Explore the admin guide
SSO, calendar permissions, activating users, adoption, recording notice, and installation.
Connect your stack and build with the API, webhooks, and MCP.
Data handling, EU processing, and documents for your review.
## Need a hand?
Reach out any time at [support@meetjamie.ai](mailto:support@meetjamie.ai), or see [Troubleshooting & Support](/enterprise/admins/troubleshooting) for your Account Managers.
# Audit Logs
Source: https://docs.meetjamie.ai/enterprise/audit-logs
An immutable record of administrative and security activity in your workspace
Audit logs give workspace admins a complete, immutable record of who did what in your workspace — logins, invites, role changes, meeting deletions, API key activity, and more. Use them to investigate security incidents, satisfy compliance requirements, and monitor sensitive activity.
Audit logs are available on the **Enterprise** plan.
## Viewing your audit log
1. Go to **Settings → Audit Log** in Jamie
2. Browse events, most recent first
Each entry records **when** it happened, the **actor** (the user, API key, or system that performed the action), the **action**, the affected **target**, and the **source** it came from (dashboard, API, mobile, desktop, webhook, or system). Sign-in context such as IP address and user agent is captured where available.
## Exporting
Click **Export CSV** on the Audit Log page to export your workspace's full history. We generate the file and email you a download link, which is valid for one hour.
## Events we capture
The tables below list every action recorded in the audit log. Each event also carries additional context (metadata) specific to that action — for example which field changed or which role was assigned. That metadata is available in the log entry and CSV export, but is intentionally not documented here as it evolves over time.
### Authentication
| Event | Description |
| --------------------------------- | ----------------------------------- |
| `auth.login_succeeded` | A user signed in successfully |
| `auth.login_failed` | A sign-in attempt failed |
| `auth.login_throttled` | A sign-in attempt was rate-limited |
| `auth.logout` | A user signed out |
| `auth.session_invalidated` | A user's session was invalidated |
| `auth.verification_code_consumed` | An email verification code was used |
### Workspace
| Event | Description |
| -------------------------------------- | ---------------------------------------------------------- |
| `workspace.created` | A workspace was created |
| `workspace.name_changed` | The workspace name was changed |
| `workspace.logo_changed` | The workspace logo was changed |
| `workspace.settings.updated` | A workspace setting was updated |
| `workspace.ip_allowlist_changed` | The workspace IP allowlist was changed |
| `workspace.integration_access_changed` | The workspace integration access configuration was changed |
| `workspace.deleted` | A workspace was deleted |
### Members & invitations
| Event | Description |
| --------------------------------------- | ------------------------------------------------- |
| `workspace.member.invited` | A member was invited to the workspace |
| `workspace.member.invite_revoked` | A pending invitation was revoked |
| `workspace.member.invite_accepted` | An invitation was accepted |
| `workspace.member.invite_declined` | An invitation was declined |
| `workspace.member.removed` | A member was removed from the workspace |
| `workspace.member.role_changed` | A member's workspace role was changed |
| `workspace.member.joined_via_domain` | A user joined automatically via a verified domain |
| `workspace.invitation_link.created` | An invitation link was created |
| `workspace.invitation_link.invalidated` | An invitation link was invalidated |
### Domains, SSO & directory sync
| Event | Description |
| ----------------------------------------- | ---------------------------------------------------------- |
| `workspace.verified_domain.added` | A verified domain was added |
| `workspace.verified_domain.removed` | A verified domain was removed |
| `workspace.sso.portal_opened` | The SSO admin portal was opened |
| `workspace.sso.enforced` | SSO enforcement was enabled |
| `workspace.sso.cert_renewal_required` | An SSO certificate is approaching expiry and needs renewal |
| `workspace.sso.cert_renewed` | An SSO certificate was renewed |
| `workspace.scim.enabled` | Directory Sync (SCIM) was enabled |
| `workspace.scim.disabled` | Directory Sync (SCIM) was disabled |
| `workspace.member.provisioned_via_scim` | A member was provisioned via SCIM |
| `workspace.member.deprovisioned_via_scim` | A member was deprovisioned via SCIM |
### User account
| Event | Description |
| ---------------------- | ---------------------------- |
| `user.profile_updated` | A user updated their profile |
| `user.account_deleted` | A user account was deleted |
### Billing
| Event | Description |
| -------------------------- | ----------------------------- |
| `billing.checkout_started` | A checkout flow was started |
| `billing.portal_opened` | The billing portal was opened |
### API keys
| Event | Description |
| --------------------- | -------------------------- |
| `api_key.created` | An API key was created |
| `api_key.updated` | An API key was updated |
| `api_key.revoked` | An API key was revoked |
| `api_key.regenerated` | An API key was regenerated |
### Webhooks
| Event | Description |
| ------------------------------------- | --------------------------------------------------- |
| `webhook.endpoint.created` | A webhook endpoint was created |
| `webhook.endpoint.updated` | A webhook endpoint was updated |
| `webhook.endpoint.deleted` | A webhook endpoint was deleted |
| `webhook.endpoint.secret_regenerated` | A webhook endpoint's signing secret was regenerated |
| `webhook.endpoint.tested` | A test event was sent to a webhook endpoint |
### Meetings
| Event | Description |
| ----------------------------------- | ----------------------------------------------------- |
| `meeting.deleted` | A meeting was deleted |
| `meeting.processed` | A meeting finished processing |
| `meeting.share.granted` | A meeting was shared with someone |
| `meeting.share.revoked` | A meeting share was revoked |
| `meeting.share.email_sent` | A meeting share email was sent |
| `meeting.share.workspace_shared` | A meeting's workspace sharing was changed |
| `meeting.share.public_link_toggled` | A meeting's public share link was enabled or disabled |
### Labels
| Event | Description |
| ------------------------- | ----------------------------------- |
| `label.created` | A label was created |
| `label.updated` | A label was updated |
| `label.deleted` | A label was deleted |
| `label.shares_updated` | A label's sharing was updated |
| `label.meetings_tagged` | Meetings were tagged with a label |
| `label.meetings_untagged` | Meetings were untagged from a label |
### Integrations
| Event | Description |
| ------------------------------ | -------------------------------------- |
| `integration.connected` | An integration was connected |
| `integration.disconnected` | An integration was disconnected |
| `integration.settings_updated` | An integration's settings were updated |
### Calendar
| Event | Description |
| ------------------------- | ---------------------------------------- |
| `calendar.connected` | A calendar was connected |
| `calendar.disconnected` | A calendar was disconnected |
| `calendar.states_changed` | Calendar recording settings were changed |
### Templates & AI
| Event | Description |
| ------------------------------------ | ------------------------------------------- |
| `template.created` | A template was created |
| `template.updated` | A template was updated |
| `template.deleted` | A template was deleted |
| `template.workspace_sharing_changed` | A template's workspace sharing was changed |
| `template.auto_apply_changed` | A template's auto-apply setting was changed |
| `agent.conversation_deleted` | An AI conversation was deleted |
### Audit log exports
| Event | Description |
| ---------------------------- | ------------------------------------------ |
| `audit_log.export_requested` | An audit log export was requested |
| `audit_log.export_completed` | An audit log export completed successfully |
| `audit_log.export_failed` | An audit log export failed |
## Questions?
If you have questions about audit logs or need help with an export, reach out to your account manager.
# Directory Sync (SCIM)
Source: https://docs.meetjamie.ai/enterprise/directory-sync
Automatically provision users and assign workspace roles from your identity provider
Directory Sync (SCIM) lets you manage your Jamie workspace membership directly from your identity provider (IdP). When it's enabled, Jamie automatically creates, updates, and deprovisions accounts as people join, change, or leave in your directory — and can assign each person the right **workspace role**.
Directory Sync is available on the **Enterprise** plan and is compatible with Microsoft Entra ID, Google Workspace, Okta, and any SCIM 2.0-compliant directory.
## Set up Directory Sync
1. Go to **Settings → Security** in Jamie
2. Click **Configure** next to **Directory Connection Settings**
3. Select your directory provider and follow the on-screen instructions to connect it
The setup wizard provides the endpoint URL and bearer token to enter in your IdP, with step-by-step instructions for each supported provider.
If you also use SSO, set up [Single sign-on](/enterprise/sso) and domain verification first — they share the same **Settings → Security** page.
## How provisioning works
Once Directory Sync is connected, your IdP becomes the source of truth for who belongs to the workspace:
* **New users** in your directory are automatically added to the Jamie workspace (and a Jamie account is created if they don't have one).
* **Updates** to a user's name or status sync automatically.
* **Removing or deactivating** a user in your directory deprovisions them from the workspace and signs them out.
While Directory Sync is active, you manage membership from your IdP — manual invites in Jamie are disabled to keep the two in sync.
## Assigning roles
Every provisioned user is a **Member** by default. To grant someone the **Admin** role, configure role assignment in your directory. There are two ways to do this.
### Option 1 — Map a group to a role (recommended)
Works for Microsoft Entra ID, Google Workspace, and other SCIM directories.
1. Create (or choose) a group in your IdP for your Jamie admins — for example, **Jamie Admins**.
2. During Directory Sync setup, in the role-assignment step, map that group to the **Admin** role.
3. Add your administrators to the group.
Anyone in the mapped group is provisioned and kept in sync as an **Admin**. Remove someone from the group and they return to **Member** on the next sync.
### Option 2 — Use the `jamie_role` attribute
If you'd rather drive the role from a user attribute than a group, map the **`jamie_role`** attribute during setup and set it on each user.
| `jamie_role` value | Resulting role |
| ------------------- | -------------- |
| `admin` | Admin |
| `member` (or unset) | Member |
The value is case-insensitive. If both a group mapping and `jamie_role` are present, **Admin** from either source wins.
Your IdP's own administrator status is **not** used to assign Jamie roles. For example, a Google Workspace "Super Admin" is **not** automatically a Jamie admin — Jamie only applies the group or `jamie_role` mapping you configure. If you configure neither, everyone is provisioned as a **Member**.
## Role safeguards
* **Member by default.** An unrecognized or missing role always falls back to **Member**, so admin access is never granted by accident.
* **Roles stay in sync.** Changing a user's group membership or `jamie_role` promotes or demotes them automatically on the next sync.
* **The last admin is protected.** Directory Sync will never remove the last remaining admin from a workspace, so a misconfiguration can't lock your team out.
## Questions?
If you run into any issues during setup, reach out to your account manager.
# IP allowlisting
Source: https://docs.meetjamie.ai/enterprise/ip-allowlisting
Restrict access to your Jamie workspace to approved IP ranges
IP allowlisting restricts access to your workspace to the IP ranges you define. Requests from any other address are rejected, whether they come from the web app, the desktop app, or the mobile app.
IP allowlisting is available on the **Enterprise** plan and is configured by workspace admins under **Settings → Security**.
## How it works
Once at least one range is saved, Jamie checks the client IP address of every request against the list.
* **Sign-in.** Members of your workspace can only sign in from an allowed address. This applies to every sign-in method: email code, Google, Microsoft, Apple, and SSO. A blocked attempt shows *Login blocked: your IP address is not allowed.*
* **Signed-in sessions.** Every request from the web, desktop, and mobile apps is checked, including meeting recording and Ask AI. Requests from outside the allowlist are rejected with *Access denied: your IP address is not allowed.*
* **Moving networks.** A member who leaves an allowed network loses access on their next request and regains it as soon as they are back on one. There is nothing to revoke or re-issue.
The allowlist applies to signed-in users. Requests authenticated with an [API key](/developers/api/access-and-security) and [MCP](/integrations/mcp) connections are not restricted by the allowlist.
## Set up the allowlist
Go to **Settings → Security** and scroll to **IP Allowlist**.
Enter one range per line, or separate them with commas. Both IPv4 and IPv6 are supported, in CIDR notation. A single address without a prefix is treated as exactly that address.
```text theme={null}
203.0.113.0/24
198.51.100.42
2001:db8:1234::/48
```
Click **Test**. Jamie compares the ranges against every IP address that accessed your workspace in the last 7 days and lists any that would be blocked. Fix the list until the check reports that all recent addresses are covered.
Click **Save**. The allowlist takes effect immediately for every member of the workspace.
Make sure your own current IP address is included before you save. An allowlist that excludes you locks everyone out, including you, and you will not be able to sign in to fix it. If that happens, contact your account manager or [support@meetjamie.ai](mailto:support@meetjamie.ai).
VPNs and Zero Trust clients such as Cloudflare WARP often route traffic over IPv6. If your team uses them, include both the IPv4 and the IPv6 ranges they exit from.
## Turn off the allowlist
Clear the field and click **Save**. An empty allowlist allows all IP addresses.
## Audit log
Changes to the allowlist and the sign-ins it blocks are recorded in the [audit log](/enterprise/audit-logs):
| Event | Description |
| -------------------------------- | --------------------------------------------------------------------------- |
| `workspace.ip_allowlist_changed` | The allowlist was changed. The entry records the previous and the new list. |
| `auth.login_failed` | A sign-in was blocked. The entry's reason is `ip_not_allowed`. |
## Questions?
If you have questions about IP allowlisting, reach out to your account manager.
# Security & Compliance
Source: https://docs.meetjamie.ai/enterprise/security-and-compliance
How Jamie handles your data, where it's processed, and the documents for your review.
* No customer data (transcripts, summaries, etc.) is ever used for AI model training.
* Audio is processed as a live stream for transcription and deleted immediately afterward — only the text transcript and summary are retained, in the EU.
* All meeting content (transient audio during transcription, transcripts, summaries, and action items) is processed exclusively within the EU.
## Links for admins
Review and sign the DPA.
Security posture, certifications, and subprocessors.
# Single sign-on (SSO)
Source: https://docs.meetjamie.ai/enterprise/sso
Set up SAML 2.0 SSO and domain verification for your Jamie workspace
Single sign-on (SSO) allows your organization to manage authentication centrally through your identity provider (IdP). Jamie supports SAML 2.0, which is compatible with Okta, Microsoft Entra ID, Google Workspace, and any other standard IdP.
Setup has two steps that must be completed in order:
1. **Verify your domain** — proves your organization owns the domain
2. **Configure SAML** — connects your IdP to Jamie
Both are found under **Settings → Security** in the Jamie app.
![SSO security settings]()
## Step 1: Verify your domain
Domain verification must be completed before SAML can be configured.
1. Go to **Settings → Security** in Jamie
2. Click **Configure** next to **Domain Verification Settings**
3. Enter the domain you want to verify (e.g. `example.com`)
4. You'll be given a TXT record to add to your DNS:
![Domain verification TXT record]()
5. Add the TXT record in your DNS provider (Cloudflare, Route 53, Google Domains, etc.)
6. Once added, verification is automatic — it usually takes under a minute, but can take up to 48 hours if you're updating an existing TXT record
You can verify multiple domains (e.g. `example.com` and `subsidiary.example.com`) by repeating this step for each one.
## Step 2: Configure SAML
Once your domain is verified:
1. Go to **Settings → Security** in Jamie
2. Click **Configure** next to **SSO-Provider Connection Settings**
3. Select your identity provider and follow the on-screen instructions
![SSO provider selection]()
You'll be provided with an **ACS URL** and **Entity ID** to enter in your IdP. The setup wizard includes step-by-step instructions for each supported provider.
### Supported identity providers
* **Okta**
* **Microsoft Entra ID** (Azure AD)
* **Google Workspace**
* **Auth0**
* **ADP**
* **Cloudflare**
* **Custom SAML** — any other SAML 2.0-compliant IdP
* **Custom OIDC**
## After setup
Once SAML is configured, all users signing in with one of your verified domains will be required to authenticate through your IdP. Users who previously signed in with email or social login will be redirected to SSO on their next login.
## SCIM provisioning
Automatically create, update, and deprovision Jamie accounts — and assign workspace roles — directly from your IdP with [Directory Sync (SCIM)](/enterprise/directory-sync).
## Questions?
If you run into any issues during setup, reach out to your account manager.
# Ask AI
Source: https://docs.meetjamie.ai/enterprise/users/ask-ai
Chat with your meetings to get instant answers, summaries, and follow-ups.
Ask AI lets you get answers and insights from your meetings in plain language.
## How to use it
Click the **Ask AI** widget at the bottom-right of your screen.
![Opening Ask AI]()
Use Ask AI across all your meetings, inside a tag's meetings, or in one specific meeting.
Draft follow-ups, find answers across your history, or summarize recent calls.
![Asking Ask AI for the key takeaways]()
# Connect your calendar
Source: https://docs.meetjamie.ai/enterprise/users/calendar-connection
Sync your calendar for smart reminders, automatic meeting titles, and better speaker identification.
Connecting your calendar is one of the most important steps when setting up Jamie, so it's best done right at the start. Many features depend on it, and it makes using Jamie much smoother. The connection lets Jamie show your upcoming meetings, set meeting titles automatically, and improve speaker identification.
## How to connect
![Calendar settings once connected]()
Click your workspace name (top-left) → **Settings**.
Go to **Integrations** → **Google Calendar / Outlook Calendar**.
Click **Connect Calendar**, sign in, and grant permissions.
Once done, Jamie syncs your **upcoming meetings** and reminds you when it's time to start recording.
![Meetings List]()
# Get started
Source: https://docs.meetjamie.ai/enterprise/users/get-started
Sign up, record your first meeting, and pick the right microphone — everything you need for your first great set of notes.
## Sign up
Go to [meetjamie.ai](https://www.meetjamie.ai/) and click **Download Jamie**.
Install Jamie on your laptop.
Sign up with **Google**, **Microsoft**, **Apple**, or your **email**. Then follow the onboarding steps in the app.
## Record your first meeting
Join a call and click **Start Jamie** when the reminder pops up, or click **Start Jamie** in the top-left corner of the app.
![Start Jamie from the meeting reminder]()
![Start Jamie from the app]()
The recorder widget shows that Jamie is running. You can see the elapsed time, change your microphone, and jot private notes in the **Scratchpad**. Click the widget when you want to stop.
![The recorder widget]()
Your summary, transcript, and action items are ready a couple of minutes after the meeting ends.
![Jamie transcribing your meeting]()
## Change your microphone
Jamie uses your system's default mic automatically, but you can choose a different one in the start dialog.
![Choosing your microphone before starting]()
Need to change devices during a call? Click the microphone icon in the recorder widget to switch.
![Changing the mic from the recorder widget]()
## What's next?
Get smart reminders and automatic meeting titles.
# Integrations
Source: https://docs.meetjamie.ai/enterprise/users/integrations
Send your meeting notes to the tools you already use — CRMs, docs, and task managers.
You can send your meeting notes straight to the tools you already use — like your CRM, docs, or other apps.
## How to connect
Go to **Settings → Integrations**, pick a tool, and click **Connect**.
![The Integrations settings]()
Share any meeting manually via the **Integrations** tab, or turn on **auto-sync** to send every new one.
Auto-sync is currently only available for **Notion**, **OneNote**, and **Google Docs**.
![Send a meeting to an integration]()
# Mobile app
Source: https://docs.meetjamie.ai/enterprise/users/mobile-app
Take Jamie with you — record in-person meetings and review notes on the go, fully synced with desktop.
![Mobile App]()
Take Jamie with you wherever you go. The Jamie mobile app is available for **iOS** on the App Store and for **Android** on the Google Play Store.
## Getting set up
Download the app, then create a new account or sign in with your existing Jamie account. Everything stays synced across devices — meetings recorded on mobile appear instantly on desktop, and vice versa.
## What you can do on mobile
* **Record in-person meetings** — perfect for on-site discussions or conversations away from your desk.
* **View your meetings and tasks** on the go.
* **Use Ask AI** to get quick insights from your summaries from anywhere.
# Support
Source: https://docs.meetjamie.ai/enterprise/users/support
Where to find help, guides, and security details when you need them.
Stuck on something or have a question? Here's where to go.
* **[Help Center](https://docs.meetjamie.ai)** — step-by-step guides and answers to common questions.
* **[Support](mailto:support@meetjamie.ai)** — reach the team directly at [support@meetjamie.ai](mailto:support@meetjamie.ai).
* **[Trust Center](https://trust.meetjamie.ai)** — security, privacy, and compliance details.
# Tags & Sharing
Source: https://docs.meetjamie.ai/enterprise/users/tags-and-sharing
Organize your meetings with tags and share notes with anyone in a couple of clicks.
Tags are customizable keywords you attach to meetings to keep them organized. You can group everything for a project, keep all of a client's calls together, or separate different teams.
## Tags
Click **+ New tag** in the sidebar, pick a name, and choose whether to share the tag or keep it private.
![Creating a new tag]()
Open a meeting and click **Add tag**.
Click a tag in the sidebar to filter your meetings down to just those.
## Sharing
To share meeting notes, click **Share** in the upper-right corner and choose whether you want to share via email or through a link.
# Templates
Source: https://docs.meetjamie.ai/enterprise/users/templates
Shape every meeting summary into a ready-to-use format that fits how you work.
Templates let you control how your meeting summaries are structured. You decide which sections to include and what goes in each, so summaries come out ready to use with the details that matter to you.
## How to use templates
Open any meeting and use the template dropdown below the summary to switch formats. Switching templates never changes your transcript.
Click **Templates → Create New** and add sections, each with a title and instructions for what it should capture.
![Building a template with sections]()
Turn on **Auto-apply** and Jamie picks the best-fit template for each meeting automatically.
![The auto-apply option]()
## Use templates from our library
Browse our [template library](https://www.meetjamie.ai/templates) for ready-made formats:
* Find a template that fits what you need.
* Click **Use Template** to add it to your workspace — you can edit it afterward.
# Welcome to Jamie!
Source: https://docs.meetjamie.ai/enterprise/users/welcome
Your home base for getting started with Jamie and getting the most out of every meeting.
## Explore the guide
Jump into any of these — or work through them top to bottom.
Sign up, record your first meeting, and set your mic.
Sync your calendar for smart reminders and titles.
Shape every summary into a ready-to-use format.
Organize your meetings and share them with anyone.
Chat with your meetings to get instant answers.
Send notes to the tools you already use.
Record and review meetings on the go.
## Need a hand?
We're here to help — reach out any time at [support@meetjamie.ai](mailto:support@meetjamie.ai), or see [Support](/enterprise/users/support).
# Delete your account
Source: https://docs.meetjamie.ai/faqs-troubleshooting/account-deletion
How account deletion works, and how to recover a deleted account.
When you delete your Jamie account, deletion is not immediate. Jamie schedules the deletion, signs you out of every device, and blocks any further login on your email address. Your data is only permanently removed once the recovery window elapses.
### The recovery window
| Account type | Recovery window |
| -------------------------- | -------------------------------------------------------------- |
| Individual users | 2 days |
| Enterprise workspace users | The workspace's configured user retention (30, 60, or 90 days) |
Enterprise workspaces control the length of the window through the `userRetentionDays` workspace setting. If it is shorter than 2 days, Jamie still enforces a 2-day minimum.
### How to delete your account
1. Open the Jamie app and go to **Settings → Account**.
2. Click **Delete account** and confirm.
3. You are signed out immediately. Your account and your email address are now locked and cannot be used to sign in through email, Google, Microsoft, Apple, or SSO.
Once the recovery window elapses, a background job hard-deletes your account and all associated data on its next run. After that point, the deletion is permanent and cannot be reversed.
### Recover a scheduled deletion
If you change your mind during the recovery window, email [support@meetjamie.ai](mailto:support@meetjamie.ai) from the address on the account and ask us to cancel the deletion. Once we restore the account, you can log in again as normal.
While the deletion is scheduled, you cannot register a new Jamie account with the same email address. If you want to start fresh on the same email, either wait for the window to elapse or contact support to cancel first.
If your account has already been hard-deleted, we can no longer recover it. You are welcome to sign up again as a new user.
# Data handling
Source: https://docs.meetjamie.ai/faqs-troubleshooting/data
What happens with my data?
At Jamie, we take your data privacy rights very seriously, and it is a priority at every step of the engineering process.
As a company located in Germany 🇩🇪, we comply with the **General Data Protection Regulation (GDPR)**, the comprehensive data protection law in the European Union (EU).
All your data is encrypted and stored using **Advanced Encryption Standard (AES)** algorithms in transit and at rest, and our team is required to go through security training and embrace best practices for data handling. We are also audited on a regular basis by an external auditor.
### FAQs
The audio recording from your computer is uploaded to a server location in Frankfurt, Germany 🇩🇪, and then processed on a serverless GPU environment from [Modal](https://modal.com/) (no data is stored at Modal). Once the processing is done and your transcript is ready, we **delete all audio files permanently.**
The transcript of a meeting is stored on a server located in Frankfurt, Germany 🇩🇪 to make it accessible to users.
After the generation of your transcript, it is further processed via an [Anthropic](https://www.anthropic.com/) or [OpenAI](https://openai.com/) API to generate your meeting notes.
**Note:** Data is **not** stored at Anthropic or OpenAI, and **not** used for training purposes.
No. Your data is never used to train Jamie's models, or any third-party models.
Some features in Jamie improve as you use the product within your own account, such as speaker identification (Jamie remembers the name you assign to a voice) and custom words (Jamie remembers the acronyms and vocabulary you add). These improvements happen on a per-account basis and are only used to generate meeting summaries for your own account — they are not used to train any models.
**Note:** The information you provide to Jamie is exclusively associated with your account. Jamie does not engage in the practice of aggregating acquired information or data for cross-utilization among distinct user accounts. Consequently, the personalized custom word list and vocal data are exclusively used to generate meeting summaries specific to your account.
If you have any more questions about data privacy, please feel free to contact us at [support@meetjamie.ai](mailto:support@meetjamie.ai).
# Language Support
Source: https://docs.meetjamie.ai/faqs-troubleshooting/language-support
What languages does Jamie support?
Jamie supports over 80 languages for transcription and summaries. You can set your preferred summary language in **Settings → Summary → Summary language**.
## Supported Languages
| | | | |
| -------------------- | ------------------- | --------------------- | ------------------------ |
| 🇿🇦 Afrikaans | 🇦🇲 Armenian | 🇦🇿 Azerbaijani | 🇧🇾 Belarusian |
| 🇧🇩 Bengali | 🇧🇦 Bosnian | 🇧🇬 Bulgarian | 🇲🇲 Burmese |
| 🇭🇰 Cantonese | 🇪🇸 Catalan | 🇵🇭 Cebuano | 🇭🇷 Croatian |
| 🇨🇿 Czech | 🇩🇰 Danish | 🇳🇱 Dutch | 🌐 English |
| 🇺🇸 English (US) | 🇬🇧 English (UK) | 🇨🇦 English (Canada) | 🇦🇺 English (Australia) |
| 🇮🇳 English (India) | 🇪🇪 Estonian | 🇵🇭 Filipino | 🇫🇮 Finnish |
| 🇫🇷 French | 🇪🇸 Galician | 🇬🇪 Georgian | 🇩🇪 German |
| 🇬🇷 Greek | 🇮🇳 Gujarati | 🇳🇬 Hausa | 🇮🇱 Hebrew |
| 🇮🇳 Hindi | 🇭🇺 Hungarian | 🇮🇸 Icelandic | 🇮🇩 Indonesian |
| 🇮🇹 Italian | 🇯🇵 Japanese | 🇮🇩 Javanese | 🇨🇻 Kabuverdianu |
| 🇮🇳 Kannada | 🇰🇿 Kazakh | 🇰🇭 Khmer | 🇰🇷 Korean |
| 🇰🇬 Kyrgyz | 🇱🇻 Latvian | 🇨🇩 Lingala | 🇱🇹 Lithuanian |
| 🇲🇰 Macedonian | 🇲🇾 Malay | 🇮🇳 Malayalam | 🇲🇹 Maltese |
| 🇳🇿 Māori | 🇮🇳 Marathi | 🇲🇳 Mongolian | 🇳🇵 Nepali |
| 🇳🇴 Norwegian | 🇫🇷 Occitan | 🇮🇳 Odia | 🇮🇷 Persian |
| 🇵🇱 Polish | 🇵🇹🇧🇷 Portuguese | 🇮🇳 Punjabi | 🇷🇴 Romanian |
| 🇷🇺 Russian | 🇷🇸 Serbian | 🇵🇰 Sindhi | 🇸🇰 Slovak |
| 🇸🇮 Slovenian | 🇪🇸 Spanish | 🇰🇪 Swahili | 🇸🇪 Swedish |
| 🇹🇯 Tajik | 🇮🇳 Tamil | 🇮🇳 Telugu | 🇹🇭 Thai |
| 🇹🇷 Turkish | 🇺🇦 Ukrainian | 🇵🇰 Urdu | 🇺🇿 Uzbek |
| 🇻🇳 Vietnamese | 🏴 Welsh | | |
## Languages with Limited Support
These languages are supported but transcription quality may vary.
| | | | |
| ------------------ | -------------------------- | ---------------------- | ---------- |
| 🇲🇼 Chichewa | 🇺🇬 Ganda | 🇱🇦 Lao | 🇰🇪 Luo |
| 🇱🇺 Luxembourgish | 🇿🇦 Northern Sotho (Pedi) | 🇳🇴 Norwegian Nynorsk | 🇿🇼 Shona |
| 🇸🇴 Somali | 🇦🇴 Umbundu | 🇸🇳 Wolof | 🇿🇦 Xhosa |
| 🇿🇦 Zulu | | | |
For the best experience, we recommend using Jamie in one of the fully supported languages listed above.
# Meeting not generating
Source: https://docs.meetjamie.ai/faqs-troubleshooting/meeting-stuck
What to do when a meeting is not generating.
The time that Jamie needs to generate a summary depends on multiple factors, such as audio quality, language, length of the meeting, and more.
Usually, Jamie takes roughly 3–5 minutes to generate your meeting notes after you have stopped the audio recording.
If **after 2–4 hours,** your summary still seems to be stuck in the generation process, please contact us at [**support@meetjamie.ai**](mailto:support@meetjamie.ai) or report the issue via the feedback box on the left sidebar of your Jamie application.
# Ask AI
Source: https://docs.meetjamie.ai/getting-started/ask-ai
Use Jamie's Ask AI to get insights about your meetings
To access Ask AI, click on the Ask AI widget on the bottom right hand side of your screen.
![Tag Filter]()
Ask AI works in 3 different ways depending on your location in the app:
* **Meetings list:** When you're in the general meetings list, Ask AI will search through all meetings.
* **Single Meeting:** Within a meeting, Ask AI will only query the current summary and transcript.
* **Tags:** When you're in a tag, Ask AI only considers the tagged meetings.
## Chat with meeting
In this mode, the conversation will be restricted to the current meeting.
Jamie users find **Chat with Meeting** very helpful for making sure all the follow ups they need to perform are done fast and accurately.
![Screenshot2025 09 15at17 01 53 Pn]()
## Chat with multiple meetings
If you are on any page other than an individual meeting, the AI will search relevant meetings for each response.
Jamie's AI will also send you the meetings that it used to formulate the response to your question.
![Ask Ai Open]()
## Connect external tools (MCP)
Jamie's Agent can connect to external services through the Model Context Protocol (MCP). Once connected, Jamie can read and act on data from tools like Slack, Notion, Linear, and GitHub — alongside everything it already knows about your meetings.
**Add a connector** in [Settings → Agent](https://app.meetjamie.ai/settings/agent), then pick which connectors are active before starting a new chat using the MCPs dropdown in the Ask AI input box. The set of connectors is locked for the lifetime of that chat; start a new chat to change them.
## Example Use Cases
### **Sales & Marketing**
* Prepare scoping emails for customers
* Draft follow up emails
* Get coaching on your sales skills
* Rework existing content based on meeting notes
### **Recruitment**
* Check that candidates gave satisfactory answers to questions
* Get a quick summary on a candidate's experience
### **Finance & Investment**
* Revisit conversations as part of your due diligence process
* Generate quick summaries to build out investment memos
### **Operations**
* Surface key details about customer preferences for the organisation of events and workshops
* Generate high quality Slack messages to share information with your colleagues
* Create split todo lists between speakers
* Narrow in on top priorities
### **Engineering**
* Create detailed follow up tasks that contain all feedback from a meeting
* Convert one off management feedback into shared team standards
# Auto-start recording
Source: https://docs.meetjamie.ai/getting-started/auto-start-recording
Let Jamie start recording your meetings automatically
With auto-start, Jamie begins recording on its own when joining a scheduled meeting - no clicks required.
Auto-start is available in the **Jamie desktop app** on **Windows** (version **5.7.7** and above) and **macOS** (version **5.7.13** and above). If you don't see the setting, update to the latest version.
## How it works
Jamie watches for two signals at the same time:
* **Your microphone becomes active** - for example when you join a call in Zoom, Google Meet, Microsoft Teams, or any other app that uses your mic.
* **A meeting is scheduled in your calendar** - either starting within the next **5 minutes** or having started within the last **10 minutes**.
When both are true, Jamie automatically starts recording and opens the recorder. If there's no matching event in your calendar, Jamie stays out of the way and does nothing.
Auto-start requires a **connected calendar** (Google Calendar or Outlook). Without a connected calendar, Jamie has no scheduled meetings to match your microphone activity against. Connect your calendar in **Settings → Integrations**.
## Managing auto-start
Auto-start is **off by default**. Turn it on when you want Jamie to handle starting for you.
To review or change the setting:
1. Open the **Jamie desktop app**
2. Go to **Settings → Preferences**
3. In section **Meeting Automation** toggle **Automatically start Jamie** on or off
You can also configure a **countdown** before Jamie starts - enabled by default - so you have a few seconds to cancel if you don't want to record this meeting. Adjust **Give me time to cancel** and the countdown length in the same section.
### Only start for known meeting apps
By default, auto-start reacts to **any** app that activates your microphone. If that's too eager - for example a voice memo or dictation tool triggering a recording - enable **Only start for known meeting apps** in the same section. Jamie will then only auto-start when your microphone is used by an app it recognizes as a meeting app.
Independently of this option, apps on your **Excluded apps** list (**Settings → Preferences → Excluded apps**) never trigger auto-start - the same list that controls the [automatic meeting detection](/getting-started/recorder) reminder.
**Only start for known meeting apps** requires desktop app version **5.7.13** or above on both Windows and macOS.
This setting can only be changed in the **Jamie desktop app**. If you're viewing your settings in the browser, open the desktop app to adjust it.
Prefer to decide meeting by meeting? Turn auto-start off and use the [automatic meeting detection](/getting-started/recorder) reminder instead, which prompts you with a **Start Jamie** button without recording automatically.
## When auto-start won't trigger
To avoid unexpected recordings, Jamie will **not** auto-start when:
* The **Automatically start Jamie** setting is turned off
* You have **no connected calendar**, or there's no meeting active or starting within the next 5 minutes
* The meeting started **more than 10 minutes ago**
* No app is using your microphone
* A recording is currently **already in progress**
* The app using your microphone is on your **Excluded apps** list
* **Only start for known meeting apps** is enabled and the app using your microphone isn't a recognized meeting app
# Auto-stop recording
Source: https://docs.meetjamie.ai/getting-started/auto-stop-recording
Let Jamie stop recording your meetings automatically
With auto-stop, Jamie ends a recording on its own when your meeting is winding down - no need to remember to click **Stop**.
Auto-stop is available in the **Jamie desktop app** on **Windows** (version **5.7.9** and above) and **macOS** (version **5.7.13** and above). If you don't see the setting, update to the latest version.
## How it works
While you're recording, Jamie watches for three signals at the same time. When all three are true at once, Jamie automatically stops the recording.
* **Your microphone becomes inactive** - for example when you leave a call in Zoom, Google Meet, Microsoft Teams, or any other app that was using your mic.
* **The scheduled meeting is near its end** - in the final quarter of the calendar event, or within the last **15 minutes** before it ends. Once the event has ended, this signal stays on, so a call that runs over its slot still stops as soon as the other two signals line up.
* **No speech has been detected for at least 15 seconds** - Jamie waits for a quiet stretch so a brief pause doesn't end your recording early.
## Recordings without a calendar meeting
When a recording isn't linked to a calendar event - for example an ad-hoc recording you started manually - Jamie falls back to a stricter rule: it stops the recording only after **10 minutes** in which your microphone was continuously inactive **and** no speech was detected. The usual countdown runs before the stop, so you can cancel it if you're still going.
With a **connected calendar**, Jamie links your recording to the matching calendar event when you start, so it can stop close to the scheduled end instead of waiting out the 10-minute fallback. Connect your calendar in **Settings → Integrations**.
## Managing auto-stop
Auto-stop is **off by default**. Turn it on when you want Jamie to handle stopping for you.
To review or change the setting:
1. Open the **Jamie desktop app**
2. Go to **Settings → Preferences**
3. In section **Meeting Automation**, toggle **Automatically stop Jamie** on or off
You can also configure a **countdown** before Jamie stops - enabled by default - so you have a few seconds to cancel if you're not done yet. Adjust **Give me time to cancel** and the countdown length in the same section.
This setting can only be changed in the **Jamie desktop app**. If you're viewing your settings in the browser, open the desktop app to adjust it.
Want Jamie to start recording automatically too? See [Auto-start recording](/getting-started/auto-start-recording). Prefer to stop manually? Leave auto-stop off and use the **Stop** button in the [recorder](/getting-started/recorder).
## When auto-stop won't trigger
To avoid ending a recording too early, Jamie will **not** auto-stop when:
* The **Automatically stop Jamie** setting is turned off
* The recording is linked to a calendar event that hasn't reached its final stretch yet
* An app is still using your microphone
* Speech was detected within the last **15 seconds** - or, for recordings without a linked calendar event, within the last **10 minutes**
# Google Calendar
Source: https://docs.meetjamie.ai/getting-started/calendar/google
How to connect your calendar in Jamie.
Connect your Google calendar with Jamie to see upcoming meetings, get automatic meeting titles, and enhanced speaker identification.
![Meetings List]()
## How to connect your calendar?
You can integrate your Google Calendar by following these steps:
1. Click on your workspace name (top left corner)
2. Go to **Settings**
3. Navigate to **Integrations** > **Google Calendar**
4. Click **Connect Google Calendar**
5. Sign in with your Google account when prompted
6. Grant the requested permissions
7. Once complete, you'll be redirected back to Jamie
![Google Calendar]()
That's it! Jamie will now sync your upcoming meetings and send you reminders when it's time to start recording.
> **Tip:** If you have multiple calendars in your Google account, you can select which ones to sync by selecting the calendars and pressing **Apply**. The system will schedule those calendars to sync.
![Google Connected]()
### FAQs
Jamie only uses the following data to increase your user experience:
* **Event metadata (Name, Time)**
send custom notifications and set meeting titles based on event name
* **Email of participants**
so you can share your meeting notes with the click of a button with others.
**Note:** Meeting notes are not automatically shared. You have full control whether you want to send them out or not.
Jamie only syncs events that look like real meetings, so your upcoming list stays focused on what matters. An event is synced when it:
* Falls within roughly the next 10 days (Jamie keeps a rolling window of upcoming events)
* Has at least two participants (you plus at least one other person)
* Hasn't been declined by you
* Isn't an all-day or multi-day event (24 hours or longer)
Jamie automatically skips events that are usually personal time rather than meetings:
* All-day and multi-day events
* Events you've declined
* Solo events with no other participants (personal holds and time blocks)
* Events whose title looks like focus or availability time — for example "Focus time", "Focus block", "Do not disturb", "No meetings", "Out of office", or "Off work"
* Google's special event types: **Focus Time**, **Out of Office**, and **Working Location** entries
Recurring meetings are synced as individual occurrences within the window, and events you cancel or delete are removed from Jamie automatically.
# Outlook
Source: https://docs.meetjamie.ai/getting-started/calendar/outlook
How to connect your calendar in Jamie.
Connect your Microsoft Outlook calendar to Jamie to see upcoming meetings, get automatic meeting titles, and enhanced speaker identification.
![Meetings List 1]()
## How to Connect Your Calendar
Connecting your Microsoft calendar takes just a few steps:
1. Click on your workspace name (top left corner)
2. Go to **Settings**
3. Navigate to **Integrations** > **Outlook**
4. Click **Connect Outlook Calendar**
5. Sign in with your Microsoft account when prompted
6. Grant the requested permissions
7. Once complete, you'll be redirected back to Jamie
![Outlook]()
That's it! Jamie will now sync your upcoming meetings and send you reminders when it's time to start recording.
> **Tip:** If you have multiple calendars in your Microsoft account, you can select which ones to sync by selecting the calendars and pressing **Apply**. The system will schedule those calendars to sync.
![Outlook Connected]()
## Connecting with a Microsoft Entra (Enterprise) Account
If your organization uses Microsoft 365 with Entra ID (formerly Azure AD), you may need administrator approval before connecting your calendar.
![Microsoft Entra]( "Microsoft Entra")
### What You'll See
When you try to connect your calendar, Microsoft may show a message saying:
> "Approval required"\
> "This app requires your admin's approval... Enter justification for requesting this app."
This happens because your organization has policies that require an administrator to review and approve third-party applications before employees can use them.
### What to Do
1. **Submit the consent request** — When you see the admin approval screen, enter justification and click "Request approval" (if available). This sends a notification to your IT administrators.
2. **Contact your IT administrator** — Let them know you'd like to use Jamie and that the app is waiting for approval in Microsoft Entra.
3. **Wait for approval** — Once an administrator approves Jamie, you'll be able to connect your calendar by following the standard steps above.
### For Administrators
Approve Jamie's calendar access for everyone in one step, without granting any other permission:
1. Ask any Jamie user in your organization to open **Settings → Integrations → Outlook Calendar** and send you the **approval link** from the "Approval for your organization" card.
2. Open the link and sign in with a Microsoft 365 administrator account.
3. Review the permissions. The link requests exactly `openid`, `profile`, `email`, `User.Read`, `Calendars.Read`, and `offline_access`.
4. Click **Accept**. A confirmation page opens; you do not need a Jamie account.
After that, users connect their calendars themselves from the same settings page. Approval does not connect anyone's calendar automatically.
The link uses Microsoft's [admin consent endpoint](https://learn.microsoft.com/en-us/entra/identity-platform/v2-admin-consent) with an explicit scope list. Do not use the generic **Grant admin consent** button in the Entra admin center for Jamie: that button approves every permission registered on the application, including ones the calendar integration never uses.
## Permissions We Request
When you connect your Microsoft calendar, Jamie requests the following permissions. Here's what each one does and why we need it:
### Required Permissions
| Permission | What it does | Why Jamie needs it |
| ----------- | -------------------------------------- | --------------------------------------------------------- |
| `openid` | Standard sign-in authentication | Required to securely sign you in |
| `profile` | Access your name and basic profile | Shows your name in Jamie and personalizes your experience |
| `email` | Access your email address | Identifies your account and enables sharing features |
| `User.Read` | Read your basic profile from Microsoft | Retrieves your account information during sign-in |
### Calendar Integration Permissions
These permissions are requested when you enable calendar integration:
| Permission | What it does | Why Jamie needs it |
| ---------------- | ------------------------------ | ------------------------------------------------------------------------------------- |
| `Calendars.Read` | Read your calendar events | Detects upcoming meetings, sends smart reminders, and auto-populates meeting titles |
| `offline_access` | Prevent constant reconnections | Keeps your calendar synced and up-to-date without requiring you to sign in repeatedly |
### What Data Does Jamie Store?
Jamie only stores the information needed to provide you with a great experience:
* **Event details:** Title, time, location, description and conferencing links (so you can join meetings directly from Jamie). Sometimes, the description of the event provides important information for speaker identification and other related metadata.
* **Attendee information:** Names and emails of meeting participants (for speaker identification)
* **Contact information:** Names, emails, and profile photos (for speaker memory)
## On-Premise Exchange Users
If your organization uses an on-premise Exchange server (or a hybrid environment where mailboxes haven't been fully migrated to Exchange Online), you may see the following error when trying to connect your calendar:
> "Resource not found: The mailbox is either inactive, soft-deleted, or is hosted on-premise."
### Why This Happens
Jamie uses the Microsoft Graph API to access your calendar. This API only works with mailboxes hosted in Exchange Online (Microsoft 365). If your mailbox is hosted on an on-premise Exchange server, the Graph API cannot reach it.
### What Are Your Options?
1. **Migrate to Exchange Online** — If your organization migrates your mailbox to Exchange Online (Microsoft 365), Jamie's calendar integration will work automatically.
2. **Hybrid environment with Exchange Web Services (EWS)** — In some cases, organizations with hybrid deployments can enable access through Exchange Web Services. This requires additional configuration on your organization's side. Please contact our support team if you'd like to explore this option.
For more technical details about on-premise requirements, see Microsoft's documentation:\
[On-Premises Architectural Requirements for the REST API](https://techcommunity.microsoft.com/blog/exchange/on-premises-architectural-requirements-for-the-rest-api/605609)
## FAQs
Jamie only syncs events that look like real meetings, so your upcoming list stays focused on what matters. An event is synced when it:
* Falls within roughly the next 10 days (Jamie keeps a rolling window of upcoming events)
* Has at least two participants (you plus at least one other person)
* Hasn't been declined by you
* Isn't an all-day or multi-day event (24 hours or longer)
Jamie automatically skips events that are usually personal time rather than meetings:
* All-day and multi-day events
* Events you've declined
* Solo events with no other participants (personal holds and time blocks)
* Events whose title looks like focus or availability time — for example "Focus time", "Focus block", "Do not disturb", "No meetings", "Out of office", or "Off work"
Recurring meetings are synced as individual occurrences within the window, and events you cancel or delete are removed from Jamie automatically.
# Edit Notes
Source: https://docs.meetjamie.ai/getting-started/edit-notes
How to edit your meeting notes.
Once Jamie has generated your meeting notes, you can make changes to your **summary, action items, and your transcript.**
To edit content, just click where you want to edit something and start typing.
You are now able to access the Jamie text editing toolbar - to open it, simply select the text that you would like to edit:
![Edit Notes]()
With the toolbar, you can:
* Change your paragraph layout - choose from regular text, heading, or list.
* Mark the text as bold, italic, or a code snippet
* Enter and edit links
You can also make use of the find and replace functionality by clicking on the search icon, expand the view by clicking on the arrow left in the find card (top right of the screen) and then enter the word you want to replace it with.
![Find Replace]()
You can then enter a replacement for the word that you have highlighted and press on the "**Replace All**" icon to change all occurrences in the summary.
# Identify Speakers
Source: https://docs.meetjamie.ai/getting-started/identify-speaker
How to identify speakers in Jamie.
To identify speakers in a meeting, Jamie uses a speaker identification process. After your meeting notes have been generated, you'll be asked to listen to an audio clip and identify the speakers who attended the meeting.
![Speaker Clips]()
Some of the speakers can be already automatically recognized and named by Jamie. You can edit auto-assigned speaker names or even assign a speaker with a contact from the People tab. Disabling automatic speaker identification is possible under the Preferences tab in Settings.
![People]()
This information will then be used to include speaker names in both your meeting summary and your transcript.
You can change the name at any point.
**Note:** Once a speaker is identified, Jamie will remember this information and automatically identify speakers in future meetings. There is no need to identify the same speaker more than once.
### How does the speaker identification process work?
1. Hover over the **Speakers** list in the header of your meeting
2. Click on the play button to play a short audio clip
3. Listen to the audio clip of each speaker
4. Type the speaker name in the text field
5. You can either create a new speaker or choose one from your **Recent Contacts**
![Speaker Identification Pn]( "Speaker Identification Pn")
**Note:** The number of speakers identified by Jamie might be more or less than the number of active speakers in the meeting. This is caused by varying audio quality during meetings or fast speaker turns.
## FAQs
On rare occasions, the number of speakers identified in Jamie can differ from the actual count of active participants. This is due to varying audio quality during meetings or fast speaker turns. Jamie might identify the same speaker as two different speakers, or miss a speaker. Reasons can be background noise, internet issues, or microphone issues. Just add the same name twice and Jamie will add it to the summary.
If the audio clip does not play any sound, don't just enter any name. This can be because Jamie identifies loud background noise or other noises during the meeting. If it turns out that Jamie did assign a speaker to that voice, you can change it in the summary.
Yes, you can edit a speaker's name. Simply click on the speaker again and rename it to the correct name.
# Meeting chat consent notice
Source: https://docs.meetjamie.ai/getting-started/meeting-chat-compliance-notice
Let Jamie post a consent notice in the meeting chat
Jamie can post a short message in the meeting chat once your recording starts, so everyone in the call sees that notes are being taken - without you having to type it yourself.
The meeting chat notice is in **beta** and **off by default**. You have to switch it on yourself, on each device, in the **Jamie desktop app** on **Windows** and **macOS** (version **5.7.16** and above). Jamie never posts in a meeting chat unless you enable it.
## How it works
A few seconds after a recording starts, Jamie looks for the meeting window. When it finds one, it opens the chat if needed and posts your notice - once per recording.
If you're still in a waiting room or the meeting hasn't opened yet, Jamie keeps looking **every 15 seconds** for the first **10 minutes** of your recording.
Posting into the chat can bring the meeting window to the front and open its chat panel, because Jamie automates sending the message for you. If you're clicking or typing yourself at that moment, the two can get in each other's way - for best results give the window a moment after joining, and Jamie keeps trying if something interrupts it.
## Supported meetings
| Meeting app | Desktop app | Browser |
| --------------- | ----------- | ---------------------------------------------- |
| Microsoft Teams | Yes | Chrome-based browsers, PWA, and Safari (macOS) |
| Google Meet | - | Chrome-based browsers, PWA, and Safari (macOS) |
| Zoom | Yes | Chrome-based browsers and Safari (macOS) |
Meetings in other apps, in a browser Jamie doesn't recognise, or on your phone are not supported.
## Turning it on
1. Open the **Jamie desktop app**
2. Go to **Settings → Notifications → Compliance**
3. Switch on **Meeting chat notice**
4. macOS only: Approve **Accessibility** access when prompted, or enable Jamie under **System Settings → Privacy & Security → Accessibility**.
Jamie needs Accessibility access on macOS to find the chat in your meeting window.
## Requiring it for your whole workspace
On the **Enterprise** plan, a workspace admin can decide the notice for everyone instead of leaving it to each member. Go to **Settings → Preferences → Workspace features → Meeting chat notice** and pick one of:
| Option | Effect |
| ---------------- | ---------------------------------------------------------------------------------- |
| Members decide | Each member turns the notice on or off themselves. This is the default |
| On for everyone | The notice is switched on for every member on desktop and they can't switch it off |
| Off for everyone | The notice stays off for every member and they can't switch it on |
Members still have to approve **Accessibility** access on macOS themselves - Jamie can't grant it for them, so their settings page keeps prompting for it until they do.
## The message
Jamie always posts the same single-line notice: "I'm using Jamie (meetjamie.ai) for automatic transcription and note-taking."
## When the notice won't be posted
* The setting is off
* The recording stopped before a meeting window appeared
* No supported meeting window showed up within the first 10 minutes of the recording starting
* The chat is unavailable - e.g. disabled by the host or takes a long time to load. Jamie does **not** retry in this case, so a message is never posted twice
* You joined a client Jamie doesn't support yet
Informing participants remains your responsibility, please check that the notice actually landed in meetings where it matters. Also see [Recording consent](/getting-started/recording-consent) for more information.
## Zoom's built-in notice options
Zoom account owners and admins on eligible plans can also configure a custom disclaimer that participants see when they start or join a meeting. Zoom lets you customize its title, description and target audience (internal, external, both).
You can use Zoom's disclaimer alongside or instead of Jamie's meeting chat notice. See [Zoom's custom disclaimer settings](https://support.zoom.com/hc/en/article?id=zm_kb\&sysparm_article=KB0066925) for setup instructions.
# Menu bar
Source: https://docs.meetjamie.ai/getting-started/menu-bar
See your next meeting and join or record with one click from the macOS menu bar
The Jamie menu bar icon on macOS shows what's coming up on your calendar and lets you join meetings or start recording without opening the app. This guide explains what appears in the menu bar and how to configure it.
The upcoming meetings menu and the next-meeting countdown require the **macOS desktop app version 5.7.14 or later**. The meeting timer is available on all supported versions.
## What you see in the menu bar
The Jamie icon lives in your macOS menu bar. Depending on your settings and what's happening, the icon can be joined by a short label and a countdown.
### Meeting timer
While a recording is running, the menu bar shows the elapsed time next to the Jamie icon. This takes priority over the next-meeting label so you always see how long the current recording has been going.
### Next meeting countdown
When no recording is running, the menu bar shows the title of your next or currently active meeting along with a countdown:
* `All Hands · in 12m` — the meeting starts in 12 minutes.
* `1:1 with Alex · 50m left` — the meeting is in progress and has 50 minutes remaining.
Jamie switches from "in Xm" to "Xm left" once a meeting starts. If an upcoming meeting begins within the next 5 minutes, Jamie prefers it over an in-progress meeting so you can jump into what's next.
Once your last meeting of the day ends, the countdown disappears and the menu bar shows the Jamie icon on its own — tomorrow's schedule stays one click away in the upcoming meetings menu.
## Upcoming meetings menu
Click the Jamie icon to see your upcoming meetings, grouped under **Today**, **Tomorrow**, or a specific date (e.g. **Fri Aug 15**).
* Up to 20 upcoming events are listed.
* Meetings from the next 3 days are considered.
* All-day events are skipped.
* Events that have already ended are hidden.
Each row shows the meeting's start time and title, for example `10:00 AM · Product review`.
### Actions on the top meeting
The topmost meeting (the next or currently active one) expands into a submenu with quick actions:
* **Open in Jamie** — opens the meeting's upcoming event view in the Jamie app.
* **Join meeting** — opens the conferencing URL from the calendar event. For Google Meet links, Jamie appends your signed-in email so the meeting opens in the correct Google account.
* **Join & Start Jamie** — joins the meeting and immediately starts recording with your default microphone.
If the meeting has no conferencing URL, the submenu shows **Start Jamie** instead of the join actions.
**Join & Start Jamie** and **Start Jamie** are disabled while another recording is already running.
Meetings further down the list open in the Jamie app when clicked.
## Configuring the menu bar
Open **Settings → Preferences → Menu bar** in the desktop app to control what appears in the menu bar.
| Toggle | What it controls |
| --------------------- | ----------------------------------------------------------------------- |
| **Meeting timer** | Show elapsed time in the menu bar during a running recording. |
| **Next meeting** | Show today's next meeting title and a countdown next to the Jamie icon. |
| **Upcoming meetings** | Show the list of upcoming meetings when you click the Jamie icon. |
Turning off **Upcoming meetings** hides the day-grouped list; the icon still opens the standard tray menu. Turning off **Next meeting** removes the label next to the icon but keeps the recording timer when a recording is in progress.
To populate the menu, connect your calendar in **Settings → Integrations**. See [Google Calendar](/getting-started/calendar/google) or [Outlook Calendar](/getting-started/calendar/outlook).
# Mobile App
Source: https://docs.meetjamie.ai/getting-started/mobile-app
Use Jamie on your phone
![Mobile App Pn]()
You can now take Jamie with you wherever you go thanks to the **Jamie mobile app**, available for **iOS** in the **App Store** and for **Android** on **Google Play**. Whether you’re already using Jamie on your laptop or just getting started, the mobile app helps you stay on top of your meetings on the move.
After downloading the app, simply **create a new account** or **sign in with your existing Jamie account**. Everything stays synced across devices - **meetings recorded on mobile appear instantly on desktop, and vice versa**.
With the mobile app, you can **record in-person meetings**, making it perfect for on-site discussions or conversations outside your usual workspace.
**Important:** Jamie **cannot record phone calls**.
Inside the app, you can **view your meetings and tasks**, and you can also use **Ask AI** to get quick insights on your summaries, wherever you are. Editing features are not yet available on mobile, but all your content remains accessible and synced.
## iPhone widgets and shortcuts
Start a new recording without opening the app. Jamie’s **New Meeting** shortcut works with Siri, the Shortcuts app, the Action button, and Control Center.
### Siri
Say **“Siri, start a new Jamie meeting”** or **“Siri, start recording with Jamie”** — Jamie opens and starts recording right away.
### Shortcuts
1. Open the **Shortcuts** app and tap **+**.
2. Search for **Jamie** and add the **New Meeting** action.
3. Run it from the Shortcuts app, a Home Screen icon, or an automation.
![New Meeting action in the Shortcuts app]()
### Action button
1. Open **Settings** → **Action Button** (iPhone 15 Pro or later).
2. Swipe to **Shortcut**, tap **Choose a Shortcut**, and select Jamie’s **New Meeting**.
3. Press and hold the Action button to start recording.
### Control Center
1. Swipe down from the top-right corner to open **Control Center**.
2. Press and hold the screen, then tap **Add a Control**.
3. Search for **Jamie** and add **New Meeting**.
4. Tap the control anytime to start recording.
![New Meeting control in Control Center]()
Take Jamie with you and stay productive, no matter where your work happens.
# Notifications
Source: https://docs.meetjamie.ai/getting-started/notifications
Customize the notifications you want to receive
Jamie can notify you about your meetings through email and desktop app notifications. You can customize these settings in **Settings → Notifications**.
## Email Notifications
Email notifications keep you informed about your meetings and updates from Jamie.
Get notified when your meeting summary is complete
Stay informed about new features and updates
Know when a teammate shares a meeting with you
Automatically notify attendees about recording
### Summary Ready
When enabled, you'll receive an email as soon as Jamie finishes processing your meeting. This is helpful if you step away after a meeting and want to be notified when your notes are ready.
### Email Updates
Receive occasional updates from Jamie about new features, improvements, and tips to get more out of your meetings.
### Team Sharing
This option is only available on **Team** and **Enterprise** plans.
Get notified via email when a teammate shares a meeting with you. This ensures you never miss important meeting notes that have been shared with you.
### Recording Notice
When enabled, Jamie will automatically send an email to your meeting attendees letting them know the meeting will be recorded. This helps with transparency and consent.
Recording notice requires a connected calendar (Google Calendar or Outlook). Connect your calendar in **Settings → Integrations** to enable this feature.
Learn more about recording consent in our [Recording Consent](/getting-started/recording-consent) guide.
## App Notifications
App notifications are available in the Jamie desktop app and help you start recording meetings quickly.
App notification settings can only be adjusted in the **Jamie desktop app**. If you're viewing this in your browser, open the Jamie app to configure these settings.
### Auto-Detected Meetings
When enabled, Jamie will monitor your system for active calls and show a "Start Jamie" reminder when a meeting is detected. This ensures you never forget to record an important meeting.
When you start a call in apps like Zoom, Google Meet, Microsoft Teams, or other video conferencing tools, Jamie will prompt you to start recording.
On macOS, you can also join your next meeting and start recording directly from the [menu bar](/getting-started/menu-bar).
### App Filtering
If you have auto-detected meetings enabled, you can customize which apps trigger reminders. This is useful if you want to:
* Disable reminders for casual video calls
* Only get reminders for specific meeting apps
* Avoid reminders during personal calls
The exclusion list lives in **Settings → Preferences** under **Excluded apps**, because it also applies to [auto-start recording](/getting-started/auto-start-recording):
1. Go to **Settings → Preferences → Excluded apps**
2. Click **Select an app** to add apps to your exclusion list
3. Selected apps will no longer trigger "Start Jamie" reminders or auto-start
You can remove apps from the exclusion list at any time by clicking the **X** next to the app name.
# Quickstart
Source: https://docs.meetjamie.ai/getting-started/quickstart
Everything you need to know to start summarizing your meetings with Jamie. This quickstart guide will walk you through how to set up your account and start summarizing your meetings.
![Welcome Image Pn]()
Jamie is the fastest and easiest way to summarize all your meetings (online & offline) and get actionable insights in minutes.
This quickstart guide will walk you through how to set up your account in Jamie and start summarizing your meetings.
## How to get started?
Everything in Jamie happens either in an individual account or a team workspace. This means you can either join your team's existing workspace or create your own individual account.
To create an account, download the app from [https://www.meetjamie.ai/](https://www.meetjamie.ai/) and sign up with Google, Microsoft, Apple, or your email address. Please follow the onboarding process in the app.
**How to start a recording?**
Mic-based reminder: You will get a mic-based reminder when you join your next online meeting. Simply click 'Start Jamie' to start recording.
![Mic Based Reminder Pn]( "Mic Based Reminder Pn")
Start recording manually: Simply head to your Jamie app and click on the **Start Jamie** button at the top left corner to start a recording.
![Start Meeting Manually Pn]( "Start Meeting Manually Pn")
Now you can fully focus on the meeting and Jamie takes care of the note-taking.
**How to stop a recording?**
Once a meeting is done, simply stop the recording by clicking on the recording icon on the left.
![Recorder Pn]( "Recorder Pn")
You can also stop the recording from the [menu bar](/getting-started/menu-bar), which on macOS also shows your next meeting and a one-click join action.
![Traybar Stop Meeting Pn]( "Traybar Stop Meeting Pn")
**Access Your Notes:** After you stop the recording, Jamie will begin generating your notes.
![Meeting Processing Pn]()
You can now review and effortlessly share the notes with your team.
**That's it** - no need for meeting bots **🎉**
To add team members to your workspace, navigate to the sidebar on the left → **Invite team**.
Jamie only captures the audio of your meetings and provides you with:
Get outstanding meeting notes
Capture all tasks and decisions
Get instant transcription for all your meetings
**Note:** Jamie can only be used on your **macOS** or **Windows** device and therefore does not require any virtual bot to join your meeting.
On Mac, Jamie requires **macOS 14.4 or later**. If you're on an older version, update macOS via **System Settings → General → Software Update**.
# Using the Recorder
Source: https://docs.meetjamie.ai/getting-started/recorder
How to record your meetings with Jamie
Jamie's recorder captures your meetings and automatically generates summaries, transcripts, and action items. This guide explains how to use the recorder from start to finish.
## Starting a Recording
There are several ways to start recording a meeting with Jamie:
When Jamie detects that you've joined a video call (e.g. Zoom, Google Meet, Microsoft Teams, etc.), a notification will appear asking if you'd like to start recording.
![Meeting Reminder]()
Simply click **Start Jamie** to begin recording.
You can disable this feature entirely in your **Notifications** settings under **App notifications**, and exclude specific apps in **Settings → Preferences** under **Excluded apps**.
You can start a recording at any time from the navigation bar within the app, or from the [macOS menu bar](/getting-started/menu-bar) using **Join & Start Jamie** on your next meeting:
![Start recording from menu bar]( "Start recording from menu bar")
Before starting, make sure your preferred microphone is connected. Jamie will use your default microphone automatically.
## During the Recording
Once you start recording, Jamie provides several features to help you during your meeting.
### The Recorder Widget
When recording, a compact floating widget appears on your screen. You can drag it anywhere to reposition it.
![Compact recorder widget]( "Compact recorder widget")
Click on the widget (not the stop button) to expand it and access the full meeting view.
### The Meeting View
The expanded meeting view gives you access to all features during your recording.
![Scratchpad]( "Scratchpad")
### Changing Your Microphone
To switch your microphone mid-meeting, you can just click on the **microphone icon** in the recorder controls to open the microphone selector dropdown and choose a different microphone.
![Change Mic]( "Change Mic")
Your audio source will switch seamlessly without interrupting the recording.
### Using the Scratchpad
During a live meeting, the **Scratchpad** tab is selected by default. Use it to write private notes - perfect for jotting down quick thoughts, noting important points to follow up on, or writing reminders for yourself. Those notes will not be incorporated into the summary created by Jamie but are standalone.
![Scratchpad]( "Scratchpad")
Your scratchpad notes are **private by default** and won't be included when you share the meeting summary with others.
## Stopping the Recording
When your meeting ends, stop the recording directly from the recorder widget or, if you have the recorder expanded to the full meeting view, from the bottom recorder bar where you will find a red **Stop** button.
If you stop a recording that's less than 5 minutes long, Jamie will show a warning. Very short recordings may not generate useful summaries. You can choose to stop anyway or continue recording.
### What if you close Jamie during the meeting?
If you accidentally close Jamie during a recording, don't worry - Jamie will ask for confirmation before stopping. If you quit Jamie, the current recording will be saved.
## After the Recording
Once you stop recording, Jamie immediately begins processing your meeting.
## Troubleshooting
Make sure your microphone is connected and recognized by your computer. Try disconnecting and reconnecting it, then refresh the microphone list.
Check that Jamie has permission to access your microphone. On Mac, go to **System Preferences > Privacy & Security > Microphone** and ensure Jamie is enabled.
Verify that automatic meeting detection is enabled in your settings, and that the video call app you're using isn't in your disallowed apps list.
# Recording consent
Source: https://docs.meetjamie.ai/getting-started/recording-consent
How to make sure that you're allowed to record
When using Jamie to take notes in your meetings, it's important to ensure all attendees are aware that the meeting is being recorded.
## Informing Attendees
There are three ways to let attendees know you'll be using Jamie:
### 1. Manual Announcement
At the beginning of your meeting, simply let attendees know that you'll be using Jamie to take notes. A quick statement like:
> "Just a heads up, I'll be using Jamie to take notes during this meeting."
### 2. Automated Recording Notice
Jamie can automatically send an email notification to your meeting attendees before the meeting starts. This email informs them that you plan to use Jamie for note-taking. You can choose how far in advance the notice is sent — from 10 minutes up to 48 hours before the meeting (4 hours by default).
![Recording Notice]( "Recording Notice")
**Requirements:**
* You must have your calendar connected to Jamie
**How it works:**
* Jamie checks your connected calendar for upcoming meetings
* Before each meeting, attendees receive an email notification at the time you've configured (10 minutes, 30 minutes, 1 hour, 4 hours, 12 hours, 24 hours, or 48 hours in advance)
* The email explains that you'll be using Jamie and briefly describes what Jamie does
* Attendees from your workspace are automatically excluded (they already know about Jamie)
**How to enable:**
1. Go to **Settings** → **Notifications**
2. Find the **Recording notice** toggle
3. Enable the toggle to start sending automatic notifications
4. Optionally adjust the **Notice timing** to control how far in advance the email is sent
### 3. Meeting Chat Notice
Instead of announcing it yourself, Jamie can post a notice in the meeting chat right after the recording starts, see [Meeting chat notice](/getting-started/meeting-chat-compliance-notice).
## Respecting Attendee Preferences
It is **required to inform** all meeting participants. The responsibility for determining the appropriate legal basis (e.g. legitimate interest) and ensuring transparency with participants lies with you as the data controller. For a detailed legal assessment of this approach, you can request our legal whitepaper through our [Trust Center](https://trust.meetjamie.ai/).
# Share Meetings
Source: https://docs.meetjamie.ai/getting-started/share-meetings
Share meetings and collaborate with your team
Jamie makes it easy to share meetings with your team. Whether you want to send a quick summary via email, share the full meeting with workspace members, or create a public link, Jamie has you covered.
Team sharing features are available on **Team** and **Enterprise** plans. Email sharing and link sharing are available on all plans.
## Sharing Options
![Email Sharing]()
Jamie offers multiple ways to share your meetings:
Send summaries directly to anyone's inbox
Share full meetings with workspace members
Create a public link anyone can view
To share a meeting, click the **Share** button in the meeting header.
## Email Sharing
Share your meeting summary via email with anyone, even if they don't have a Jamie account.
### How It Works
1. Click **Share** on any meeting
2. Enter an email address and click **Send**
3. The recipient receives the summary in their inbox
Meeting participants are automatically shown for quick sharing. You can send to individual participants or use **Send to all** to share with everyone at once.
Email sharing only includes the **summary**. The transcript and tasks are not included. For full meeting access, use Team sharing or the public link instead.
## Team Sharing
Share complete meetings with members of your Jamie workspace. This is the best option when you want colleagues to have full access to all meeting content within Jamie.
Team sharing requires a **Team** or **Enterprise** plan. [Upgrade your plan](https://app.meetjamie.ai/settings/billing) to unlock this feature.
![Team Sharing]()
### How It Works
1. Click **Share** on any meeting
2. Go to the **Team** tab
3. Search for a teammate by name or email
4. Click on their name to share
Participants who were in the meeting are shown first, making it easy to share notes with attendees.
### Viewing Shared Meetings
Meetings shared with you appear in the **Shared with me** section, accessible from the main navigation.
![Shared With Me]()
You can:
* **Filter by person** — See only meetings from a specific teammate
* **Filter by date** — Jump to meetings from a specific time period
* **View any shared meeting** — Click to see the full summary, transcript, and tasks
Each meeting shows who shared it with you, so you always know the source.
### Managing Access
**As the meeting owner, you can:**
* **Revoke access** — Click on a shared teammate and select "Revoke access" to remove their access
**As a recipient, you can:**
* **Remove from your list** — Remove a shared meeting from your "Shared with me" section (this doesn't affect others' access)
## Link Sharing
Create a public link that anyone can use to view your meeting.
![Email Sharing]()
### How It Works
1. Click **Share** on any meeting
2. In the **Email** tab, find the **Link sharing** section at the very bottom
3. Toggle the switch to make the link **live**
4. Click **Copy link** to copy it to your clipboard
When the link is live, **anyone with the link can view the meeting**. Make sure you only share links with intended recipients.
### What Link Viewers See
People viewing via a shared link see a read-only version of your meeting with:
* Meeting title and metadata
* Summary content
* Transcript content
They can copy content but cannot edit anything.
### Disabling a Link
To revoke access via a shared link, simply toggle the link switch off. The link will immediately stop working for anyone who has it.
## Notifications
Control how you're notified about shared meetings in [Notifications](/getting-started/notifications).
* **Team sharing emails** — Get notified when a teammate shares a meeting with you (Team/Enterprise only)
## Integration Sharing
You can also send your meeting content to external tools like Notion, Google Docs, HubSpot, Salesforce, and more. Learn how to set up and use integrations in [Integrations](/integrations/overview).
# Meeting Output
Source: https://docs.meetjamie.ai/getting-started/summary
What you get after Jamie processes your meeting
Once you stop your meeting, Jamie starts processing your meeting immediately. You will see live updates on each processing step and how long it is roughly going to take to complete the summary.
![Summary Card]()
### **Processing Steps**
Jamie processes your meeting in the following order:
1. **Transcribing** — Converting the audio to text
2. **Speaker Matching** — Identifying who said what (if Speaker Memory is enabled)
3. **Writing Summary** — Creating your meeting notes
4. **Creating Tasks** — Extracting action items
### **Expected Wait Times**
Processing typically takes about **5 - 10 minutes** total, though this can vary based on meeting length.
### **What You'll Get**
When processing completes, you'll have access to:
AI-generated meeting notes in a structured format
Full word-for-word transcript of your meeting
Action items extracted from the meeting with assignees
Your private notes from during the meeting
All content is fully editable - you can make changes, add notes, and customize everything to your needs.
## Summary
The **Summary** tab contains your generated meeting notes. Jamie structures the notes with an **Executive Summary** and a **Full Summary**, structured by topics discussed in the meeting. If you'd like to have your summary in a different format, you can use or create [summary templates](/getting-started/templates).
![Summary View]()
You can edit the summary directly - click anywhere in the text to make changes. Your edits are saved automatically.
You can set the detail level for your summaries in the **Summary** settings under **Summary detail**. You can choose between **Extensive** (default) and **Brief**.
## Transcript
The **Transcript** tab shows the full word-for-word record of your meeting, organized by speaker.
![Transcript View]()
## Tasks
The **Tasks** tab lists all action items Jamie extracted from your meeting.
![Tasks View]()
For each task, you can:
* **Mark as complete** - Click the checkbox
* **Edit the text** - Click on the task to edit it
* **Assign to someone** - Click the assign icon to add an assignee
* **Delete** - Hover over the task and click the delete icon
* **Add new tasks** - Click the + button to create additional tasks
## Editing Content
To edit content, just click where you want to edit something and start typing.
You are now able to access the Jamie text editing toolbar - to open it, simply select the text that you would like to edit:
## Copying Content
You can copy any content to your clipboard:
* Use the **copy icon** in the header to copy the current tab's content
* Select text and use `Ctrl/Cmd + C` to copy specific sections
When you paste into apps like Notion or Google Docs, the formatting is preserved.
# Tags
Source: https://docs.meetjamie.ai/getting-started/tags
Organise your meetings into projects, collaborate with colleagues using shared tags.
## What are tags?
Tags are keywords you attach to meetings to keep your notes organised. They are fully customisable so you can build a system around projects, clients, teams, or anything else you care about. A meeting can have multiple tags, and you can share tags with teammates so the right people see the right meetings.
## When you'd use tags
Group every meeting related to a project in one place so you can pull up the whole history in two clicks.
Tag every call with a client so all discovery, kickoff, and review meetings live together.
Use tags to separate engineering, sales, and operations meetings without spinning up new workspaces.
Track recurring topics such as hiring, planning, or retros across the whole organisation.
## How to use
In the left sidebar, click **+ New tag**.
Pick **Private** if the tag is just for you, or **Shared** to invite teammates. Shared tags are available on Team and Enterprise plans.
Choose a colour that helps you spot the tag in the sidebar, then enter a short, descriptive name.
For shared tags, select the teammates who should be able to add their own meetings to the tag.
![Creating a tag in Jamie]()
From your meetings list, click any meeting to open the summary.
In the meeting header, click 🏷️ **Add tag**.
Start typing to filter your tags. If the name does not exist yet, select **Create** to make a new tag inline without leaving the meeting.
![Adding a tag to a meeting]()
A meeting can have as many tags as you like. Use one for the client, one for the project, and one for the meeting type if that is how you think about it.
Selecting a tag filters your meetings list to just the meetings with that tag.
While filtered to a tag, you can still search by keyword to narrow further.
Click the tag again, or pick **All meetings**, to clear the filter.
![Filtering meetings by tag]()
## Private vs shared tags
**Private tags** are only visible to you. They are great for personal organisation when you do not want to involve teammates.
**Shared tags** let you share a curated slice of your meeting library without giving teammates access to everything. When you add a meeting to a shared tag, every contributor of that tag can view that meeting. Shared tags are marked with a small users icon throughout the app.
Shared tags are available on the Team and Enterprise plans.
### How shared tags work
* **As the owner**: you create the tag and choose which teammates can contribute. Only the owner can add or remove members.
* **As a contributor**: you can view every meeting in the tag and add your own meetings to it.
### Managing shared tag members
In the sidebar, click the three dots next to the shared tag.
Choose **Edit** or **Share** to open the sharing settings.
Update the list of contributors. Removing all contributors turns the tag back into a private tag.
![Editing a tag's sharing settings]()
### Leaving a shared tag
If you are a contributor and no longer want access to a shared tag, open its menu in the sidebar and select **Remove**. The tag and its meetings will no longer appear for you.
## Tag suggestions
Jamie looks at each new meeting and suggests the tags that fit. By default, suggested tags show up next to the meeting and only apply if you accept them. If you'd rather not review them one by one, you can let Jamie [apply them automatically](#applying-tags-automatically).
The more descriptive your tag names are, and the more meetings you have already tagged, the better the suggestions become. A handful of well-tagged meetings is usually enough to get useful results.
### Turning suggestions on or off
![Tag suggestions]()
Go to **Settings → Tags**.
Scroll to the **Tag suggestions** section below the tags table.
Use the **Suggest tags for new meetings** toggle to turn suggestions on or off. The change applies to all of your future meetings.
Jamie only suggests tags you have already created. It will not create new tags for you.
## Applying tags automatically
If you find yourself accepting most suggestions anyway, you can let Jamie apply them for you. With automatic application turned on, suggested tags are added to new meetings straight away — there's no review step. You can still remove any tag that doesn't fit.
Automatic application is **off by default**: out of the box Jamie only ever suggests tags. After you've accepted a few suggestions, Jamie will offer to turn it on for you with a one-tap toast.
### Choosing which tags get applied
When you enable automatic application you decide how far it goes:
* **Private tags only** *(default)* — Jamie automatically applies only your personal tags. Shared tags are still suggested for you to review, so you stay in control of what your teammates see.
* **Private and shared tags** — Jamie also applies the tags you share with teammates. Keep in mind that adding a meeting to a shared tag makes it visible to everyone who contributes to that tag.
Go to **Settings → Tags** and find the **Tag suggestions** section.
Enable **Apply suggested tags automatically**. (Tag suggestions need to be on first.)
Choose **Private tags only** or **Private and shared tags**. New meetings are tagged automatically from now on.
Choosing **Private and shared tags** can change who sees a meeting: applying a shared tag exposes the meeting to every contributor on that tag. Use **Private tags only** if you'd rather review shared tags yourself.
## Tips and common questions
Yes. Open the tag menu in the sidebar and pick **Edit**. Renaming a tag updates it everywhere it has been applied — you never need to re-tag old meetings.
The tag is removed from every meeting that had it. The meetings themselves stay untouched. If the tag was shared, contributors lose access at the same time.
Only the tag owner can remove contributors. As a contributor you can always leave the tag yourself by opening its menu in the sidebar and selecting **Remove**.
Two common reasons: you have not created any tags yet, or suggestions are turned off in **Settings → Tags**. Suggestions also need a few existing tagged meetings to learn from.
Yes. That is exactly what shared tags are for. Contributors only see meetings that have been added to the shared tag, not the rest of your meeting library.
No. Shared tags require the Team or Enterprise plan. Private tags are available on every plan.
## Limits and things to keep in mind
Tag names must be non-empty and unique within your account. Renaming a tag to match an existing one is not allowed.
* Suggestions usually appear within a few seconds of a meeting finishing.
* Removing every contributor from a shared tag turns it back into a private tag.
* Filtering and search can be combined — filter to a tag and then search within it for a specific keyword.
* Suggestions only consider tags that already exist on your account; Jamie will never create a new tag for you automatically.
# Templates
Source: https://docs.meetjamie.ai/getting-started/templates
Control how your meeting summaries are formatted with templates
## What are templates?
Templates let you control the structure and content of your meeting summaries. You decide which sections to include and what belongs in each one, so your summaries come out ready to use with the details you care about.
## When you'd use a template
Every summary looks the same across the team so updates, decisions, and next steps are always easy to find.
Standups, 1:1s, client calls, retros. Each gets its own format so people can skim for exactly what they care about.
Every call captures pain points, objections, and next steps in the same structure.
Instead of reformatting notes after every call, templates give you publish-ready summaries in one click.
## How to use
Go to your meetings list and click on any meeting.
Look below the summary. You will see a dropdown showing the current template name (such as "Default").
![Jamie Template Dropdown]()
Click the dropdown to see your available templates. Click on any template to apply it.
Jamie will regenerate the summary using that template's format. A checkmark shows which template is currently applied.
From the template dropdown, click **New template**.
You can either click **start from scratch** to create a blank template, or select one of the default templates as a starting point (Jamie will make a copy for you to edit).
Give your template a name by editing the title at the top.
Fill in the **Meeting Context** field to describe when this template should be used (for example, "Weekly team sync meetings", "Interviews with potential candidates").
Add and edit **Sections**. Each section has a **title** (like "Key Decisions" or "Action Items") and **Instructions** that tell Jamie what to include in that section.
Click on the icon to update it.
![Jamie Template Dropdown]()
Your changes save automatically. No need to click a save button.
Not happy with the template you've chosen? Go back to your previous notes instantly.
Click the template dropdown at the top of your notes.
Choose the template called **"Default"**.
Jamie remembers the original layout and switches your notes back to it.
## Automatically apply templates
Instead of manually choosing a template after every meeting, you can let Jamie pick the right one for you.
### How it works
1. **You mark templates for auto-apply**: Enable auto-apply on any templates you want Jamie to consider.
2. **Jamie classifies each meeting**: After a meeting ends, Jamie reviews which of your auto-apply templates best matches the meeting content.
3. **The best fit gets applied**: If Jamie finds a relevant template, it applies that template automatically. If none of your auto-apply templates fit, Jamie uses the default format.
The **Meeting Context** field you fill in when creating a template helps Jamie understand when to use it. Be descriptive, for example, "Weekly engineering standups" or "Sales discovery calls with new prospects." If your calendar is connected, referencing the meeting title can help Jamie match templates more accurately (e.g., "Meetings titled 'Sprint Planning'" or "Calls with 'Demo' in the title").
### Enabling auto-apply on a template
Go to your template list and select the template you want to auto-apply.
Find the **Auto-apply** drop-down and switch it on.
![Jamie Template Dropdown]()
You can enable auto-apply on multiple templates. Jamie will choose the most relevant one for each meeting.
Auto-apply only considers templates you've explicitly marked. Your other templates remain available for manual use but won't be applied automatically.
## Tips and common questions
Be specific about what you want, both in terms of content and formatting. For example, an interview template with a section titled "Work Experience" could say: "List the candidate’s experience in chronological order, including their title, the company name, and how long they spent there."
You can switch templates as many times as you like. Each time you apply a different template, Jamie regenerates the summary in that new format.
No. Templates only change how the summary is formatted. Your original transcript stays the same.
To customize a Jamie created template, use the **Duplicate** button to make your own copy, then edit that.
Personal templates are private to your account, only you can see and use them. If you share a template with your workspace (Enterprise & Team plans only), all workspace members can use it.
Meetings that used that template keep their existing summaries. You just won't be able to apply that template to new meetings.
## Limits and things to keep in mind
Each template needs at least one section with a title and instructions to work properly. Sections with a missing title or instructions will be ignored.
* When you apply a template, it may take a few moments for Jamie to generate the new summary. Very long templates or meetings may take longer to process.
* If you close Jamie or click away while a template is applying, it stops and your notes return to how they were.
* Templates work best when the meeting transcript has enough content for each section. If the meeting didn't cover a topic, that section may be brief or empty.
# Affinity
Source: https://docs.meetjamie.ai/integrations/affinity
Log meeting notes to Affinity interactions and notes
Connect Jamie to Affinity to create notes linked to people, companies, and opportunities, or attach your meeting notes to interactions that already exist in Affinity.
Affinity integration requires an **Enterprise** plan.
## Setup
Affinity connects with a workspace-wide API key. A workspace admin sets it up once for the whole team.
1. In Affinity, go to **Settings → Manage Apps** (under **Developer Tools**)
2. Click **New App** and create an API key for Jamie
3. In Jamie, go to **Settings → Integrations → Affinity**
4. Paste the API key and click **Connect**
5. Once verified, your workspace will show the connection as active
Generating an API key requires the **"Generate an API key"** permission in Affinity, which is controlled by your Affinity admin. API access is also only available on select Affinity license types.
The API key is shared at the workspace level, so every member can send meetings to Affinity once an admin has connected it. Only admins can connect or disconnect the integration.
## Sending Meetings to Affinity
1. Open a meeting in Jamie
2. Click the **Share** button and navigate to **Integrations**
3. Select **Send to Affinity**
When the modal opens, Jamie automatically matches the meeting's calendar participants (and your own email) to Affinity people, and pre-selects those people and their companies.
Rich text formatting from your meeting notes (bold text and nested lists) is preserved when sent to Affinity.
### Creating a note
1. Review the matched **People** and **Companies**, then add any **Opportunities**
2. (Optional) Attach the note to an existing Affinity interaction — see below
3. Click **Create Note** (or **Send to Interaction** if you selected one)
Jamie creates a note in Affinity with your meeting content, linked to the selected people, companies, and opportunities.
A note must be linked to at least one person, company, or opportunity — or attached to an interaction. Emails that could not be matched to an Affinity person are shown via the help icon below the fields.
### Attaching to an existing interaction
In the **Attach to interaction** section, you can anchor your note to an interaction that already exists in Affinity (for example, one synced from your calendar).
1. Add an external **Attendee** to find their Affinity interactions
2. Search for and select an **Interaction** from the dropdown
Jamie surfaces interactions linked to the selected attendees and tries to smart-match by meeting title. When you send, your note is anchored to the chosen interaction.
### Updating a note
If you've already sent this meeting to Affinity, the button reads **Update Note**. Sending again updates the existing note in place — with your latest meeting content and the currently selected people, companies, and opportunities — instead of creating a duplicate.
When updating, the interaction attachment is hidden because a note's interaction link cannot be changed after it is created.
## Settings
Once connected, each member can configure what content to include when sending:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full transcript in HTML format |
At least one option must be enabled.
# Asana
Source: https://docs.meetjamie.ai/integrations/asana
Create tasks from meetings in Asana
Connect Jamie to Asana to send meeting action items as tasks and attach meeting notes to projects.
Asana integration requires a **Pro**, **Team**, or **Enterprise** plan.
## Connecting Asana
1. Go to **Settings → Integrations → Asana**
2. Click **Connect Asana**
3. Select your Asana account and authorize the connection
## Sending Meetings to Asana
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to Asana**
4. Search for and select a project
5. Click **Send**
After sending:
* **Tasks** from your meeting appear in the project's task list
* **Meeting notes** are attached as a PDF in the project's Files section
## Settings
![Asana Settings]()
Configure what content to include in the attached PDF:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full meeting transcript |
At least one option must be enabled.
# Attio
Source: https://docs.meetjamie.ai/integrations/attio
Sync meeting notes to your Attio workspace
Connect Jamie to Attio to log meeting notes to people and company records.
Attio integration requires a **Pro**, **Team**, or **Enterprise** plan.
## Connecting Attio
1. Go to **Settings → Integrations → Attio**
2. Click **Connect Attio**
3. Select your Attio account and authorize the connection
## Sending Meetings to Attio
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to Attio**
4. Search for and select a person or company record
5. Click **Send**
## Settings
![Attio Settings]()
Configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full meeting transcript |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# DealCloud
Source: https://docs.meetjamie.ai/integrations/dealcloud
Log meeting notes to DealCloud interactions
Connect Jamie to DealCloud to log meeting notes as interactions or attach them to existing ones.
DealCloud integration requires a **Team** or **Enterprise** plan.
## Setup
DealCloud uses API credentials that need to be configured by Jamie's support team.
1. Go to **Settings → Integrations → DealCloud**
2. Follow the instructions to contact support with your DealCloud API credentials (Site URL, Client ID, and API Key)
3. Once configured, your workspace will show the connection as active
Your DealCloud admin can find the API credentials in **DealCloud → Settings → API Management**.
## Sending Meetings to DealCloud
1. Open a meeting in Jamie
2. Click the **Share** button and navigate to **Integrations**
3. Select **Send to DealCloud**
You can either add notes to an existing interaction or create a new one.
### Add to Existing Interaction
1. Search for and select an existing interaction from the dropdown
2. Click **Send**
Your meeting notes will be appended to the selected interaction's notes field.
### Create New Interaction
1. Switch to the **New Interaction** tab
2. Fill in the fields:
| Field | Description |
| ---------------------- | ------------------------------------------------------ |
| **Subject** | Pre-filled with the meeting title |
| **Date** | Defaults to the meeting start date |
| **Type** | Interaction type (defaults to "Meeting" if available) |
| **Internal Attendees** | Jamie participants matched to DealCloud users by email |
| **Companies** | Search and select companies |
| **Contacts** | Search and select contacts (auto-matched by email) |
| **Deal** | Optionally associate a deal (auto-searched by company) |
3. Click **Create & Send**
The interaction is created in DealCloud with your meeting notes attached.
## Settings
Once connected, configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full transcript in HTML format |
At least one option must be enabled.
## Field Mapping (Admin Only)
DealCloud sites have custom schemas. Jamie automatically discovers the correct fields for your site. If the auto-detection is incorrect, admins can override the field mapping:
1. Go to **Settings → Integrations → DealCloud**
2. Expand the **Field Mapping** section
3. Adjust any core fields (Subject, Date, Notes, etc.) using the dropdowns
4. Optionally add custom reference fields (e.g., Opportunities, Funds) that will appear in the New Interaction modal
# Dynamics 365
Source: https://docs.meetjamie.ai/integrations/dynamics365
Save meeting notes to Dynamics 365 Sales records and meetings
Connect Jamie to Dynamics 365 Sales to save your meeting notes as notes (annotations) linked to Leads, Contacts, Opportunities, and Accounts, or add them to an existing Dynamics 365 meeting.
Dynamics 365 integration requires a **Pro**, **Team**, or **Enterprise** plan.
## Admin Setup (One-Time)
A Dynamics 365 admin should complete this setup before users connect:
1. Ensure the Jamie app registration has the necessary API permissions in your Azure AD / Entra ID tenant
2. Go to **Settings → Integrations → Dynamics 365** and click **Connect Dynamics 365**
3. Enter your environment subdomain and log in with your admin account
4. Grant the required permissions on the OAuth consent screen
## Connecting Dynamics 365
After admin setup, each user can connect:
1. Go to **Settings → Integrations → Dynamics 365**
2. Click **Connect Dynamics 365**
3. Enter your environment **subdomain** (e.g. `org123.crm`) — you can find this in your Dynamics 365 URL, which looks like `https://.dynamics.com`
4. Log in with your Microsoft account and grant access
5. Once verified, the integration shows as **Active**
You only need the subdomain — the `.dynamics.com` suffix is added automatically. Pasting the full URL works too; Jamie cleans it up for you.
## Sending Meetings to Dynamics 365
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button and navigate to **Integrations**
3. Select **Send to Dynamics 365**
4. Choose how you want to send the meeting:
### Create a note & link to records
1. Search for and select one or more **Leads**, **Contacts**, **Opportunities**, or **Accounts**
2. Click **Send**
Jamie creates a note in Dynamics 365 with your meeting content and links it to each selected record.
Dynamics 365 notes can only be linked to a single record, so Jamie creates one note per selected record.
### Update an existing meeting
1. Search for and select an existing Dynamics 365 **meeting** (appointment)
2. Click **Send**
Your meeting notes are added to the selected meeting's description.
### Updating a note
If you've already sent this meeting to Dynamics 365, the **Create note** option becomes **Update note & linked records**. Sending again updates the existing note content and adjusts the linked records instead of creating a duplicate.
## Settings
Once connected, each member can configure what content to include when sending:
| Option | Description |
| -------------- | ---------------------------------------------- |
| **Summary** | Meeting notes with executive summary and notes |
| **Transcript** | Full meeting transcript |
| **Tasks** | Action items and tasks from the meeting |
Use the **Sync all** toggle to include everything at once.
At least one option must be enabled.
# Google Docs
Source: https://docs.meetjamie.ai/integrations/google-docs
Export meetings to Google Docs
Connect Jamie to Google Docs to create documents with your meeting summaries, transcripts, and tasks.
## Connecting Google Docs
1. Go to **Settings → Integrations → Google Docs**
2. Click **Connect Google Docs**
3. Select your Google account and authorize the connection
## Sending Meetings to Google Docs
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to Google Docs**
Jamie creates a new document in your Google Drive with the meeting content.
## Automatic Sync
Enable **Automatic sync** to create a Google Doc for every meeting automatically after processing completes. Toggle this in **Settings → Integrations → Google Docs**.
## Settings
![Googledocs Settings]()
Configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full meeting transcript |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# HubSpot
Source: https://docs.meetjamie.ai/integrations/hubspot
Log meeting notes to your HubSpot CRM
Connect Jamie to HubSpot to seamlessly log meeting notes to contacts, companies, and deals.
HubSpot integration requires a **Pro**, **Team**, or **Enterprise** plan.
## Connecting HubSpot
1. Go to **Settings → Integrations → HubSpot**
2. Click **Connect HubSpot**
3. Select your HubSpot account and authorize the connection
## Sending Meetings to HubSpot
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button and navigate to **Integrations**
3. Select **Send to HubSpot**
4. Search for and select a contact, company, or deal
5. Click **Send**
Your meeting notes appear in the **Notes** section of the selected record. If transcript is enabled, it's attached as a PDF.
## Settings
![Hubspot Settings]()
Once connected, configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full transcript attached as PDF |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# MCP
Source: https://docs.meetjamie.ai/integrations/mcp
Connect Claude, ChatGPT, Cursor, and other AI tools to your Jamie meeting notes
Connect your AI tools to your Jamie meeting notes with MCP (Model Context Protocol). Once connected, you can search through your meetings, find specific topics discussed in past meetings, extract action items, and answer questions based on your meeting history — all from your favorite AI assistant.
MCP is available on the **Pro**, **Team**, and **Enterprise** plans. If you're
on the Free or Plus plan, [upgrade your
plan](https://www.meetjamie.ai/pricing) to connect your AI tools.
We're working on adding Jamie to the Claude and ChatGPT connector directories
for one-click setup. In the meantime, you can connect by adding Jamie as a
custom MCP server using the instructions below.
## Pre-requisites
* A Jamie account on a Pro, Team, or Enterprise plan, with existing meeting notes
* An AI tool that supports MCP, such as Claude, ChatGPT, Cursor, Windsurf, or Microsoft Copilot
## How to connect
### Claude
Custom connectors require a Claude Pro, Max, Team, or Enterprise plan. Free
users are limited to one custom connector.
1. Open [Claude](https://claude.ai) and sign in
2. Go to [**Customize → Connectors**](https://claude.ai/customize/connectors)
3. Click **+** then **Add custom connector**
4. Enter the Jamie MCP server URL:
```text theme={null}
https://mcp.meetjamie.ai/mcp
```
5. Click **Add**, then complete the OAuth sign-in with your Jamie account
6. In a new chat, click **+** → **Connectors** and toggle Jamie on
On Team and Enterprise plans, an Owner must first add the connector in
[**Organization settings →
Connectors**](https://claude.ai/admin-settings/connectors). Members can then
connect to it from **Customize → Connectors**.
### ChatGPT
MCP connectors require a ChatGPT Plus, Pro, or Enterprise plan.
1. Open [ChatGPT](https://chatgpt.com) and sign in
2. Go to **Settings → Connectors** (or **Developer** section)
3. Enable **Developer Mode** if not already enabled
4. Add a new connector with the URL:
```text theme={null}
https://mcp.meetjamie.ai/mcp
```
5. Set authentication type to **OAuth** and complete the sign-in flow
6. In a new chat, click **+** → **More → Developer mode** and toggle Jamie on
### Microsoft Copilot
Jamie is available as a connector in **Microsoft Copilot Studio**, where you build and extend the agents used by Microsoft 365 Copilot. You add Jamie as a Model Context Protocol tool on an agent, and that agent can then read your meetings, transcripts, tasks, and tags.
Connecting an MCP server requires a Copilot Studio license, and the agent must
have **generative orchestration** turned on (in the agent's **Settings**). MCP
tools don't work with classic orchestration.
1. In [Copilot Studio](https://copilotstudio.microsoft.com), open the agent you want to extend
2. Go to the **Tools** page for your agent
3. Select **Add a tool**
4. Select **Model Context Protocol** — a list of available MCP connectors appears
5. Find and select **Jamie AI**
6. Authorize the connection — sign in with your Jamie account when prompted
7. Select **Add and configure**
Jamie's tools are added and turned on by default. To limit which ones the agent can use, open the Jamie tool from the **Tools** tab, turn off **Allow all**, and use the individual toggles.
### Claude Code
1. Run `claude` in your terminal
2. Add the Jamie MCP server:
```bash theme={null}
claude mcp add jamie --transport http https://mcp.meetjamie.ai/mcp
```
3. Open a new terminal tab and run `claude` again
4. Run `/mcp`, select the Jamie MCP, and select **Authenticate**
5. Ask Claude to reference your meetings
### Cursor
1. Open **Cursor Settings** (Cmd+Shift+J) → **Tools & MCP**
2. Click **Add new MCP server**
3. Set the type to **Streamable HTTP** and enter the URL:
```text theme={null}
https://mcp.meetjamie.ai/mcp
```
4. Click **Install** — a browser window will open for OAuth authentication
5. Sign in with your Jamie account
6. Your meeting tools will appear in the MCP panel
You can also add it via `.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally:
```json theme={null}
{
"mcpServers": {
"jamie": {
"url": "https://mcp.meetjamie.ai/mcp"
}
}
}
```
### Windsurf
1. Open **Windsurf Settings → MCP**
2. Add a new server with the URL:
```text theme={null}
https://mcp.meetjamie.ai/mcp
```
3. Complete OAuth authentication when prompted
### Other AI tools
You can connect any MCP-compatible tool using the public URL:
```text theme={null}
https://mcp.meetjamie.ai/mcp
```
Your AI tool must support:
* [Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http)
* **OAuth 2.0 authentication** — Jamie uses browser-based OAuth, so your tool needs to open a browser window for you to sign in. No API keys or client secrets are needed — credentials are handled automatically via Dynamic Client Registration.
## Available tools
Once connected, these tools are available to your AI assistant:
| Tool | Description | Example prompts |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| `list_meetings` | List your meetings with optional date range, tag filter, and pagination | *What meetings did I have last week?* |
| `get_meeting` | Get full details of a meeting including summary, transcript, tasks, and participants | *Show me the notes from my standup this morning* |
| `get_meeting_transcript` | Read a long meeting's full transcript in sequential pages (use after `get_meeting` when its transcript is truncated) | *Get the complete transcript of yesterday's planning call* |
| `search_meetings` | Semantic search across your meeting content (last 6 months by default) | *What did the team decide about the pricing change?* |
| `search_people` | Look up people from your contacts by email address, with their name, role, and company when available | *Who is [jordan@acme.com](mailto:jordan@acme.com) and what's their role?* |
| `list_tasks` | List action items from your meetings with filters for date, status, and assignee | *What are my open action items?* |
| `create_tasks` | Create action items on a meeting you own, with optional assignee, due date, and priority | *Add a task for Sam to send the proposal by Friday* |
| `list_templates` | List your meeting summary templates, including built-in and workspace-shared ones | *What summary templates do I have?* |
| `upsert_template` | Create a new meeting summary template or update one you created | *Create a template for my 1:1s with sections for wins and blockers* |
| `list_tags` | List all tags available to you, including tags shared by teammates | *What tags do I have?* |
| `create_tag` | Create a new tag (label) you own, with an optional color | *Create a tag called "Q3 Planning"* |
| `update_tag` | Rename a tag you own and/or change its color | *Rename my "Sales" tag to "Revenue"* |
| `delete_tag` | Permanently delete a tag you own (removes it from all meetings; cannot be undone) | *Delete the "Old Project" tag* |
| `set_tag_sharing` | Share a tag you own with workspace teammates, or make it private | *Share my "Hiring" tag with [sam@acme.com](mailto:sam@acme.com)* |
| `add_tag_to_meetings` | Add a tag to one or more meetings you own | *Tag yesterday's interview with "Hiring"* |
| `remove_tag_from_meetings` | Remove a tag from one or more meetings you own | *Remove the "Hiring" tag from that meeting* |
## Troubleshooting
### MCP tools not working
If your AI tool can't access your meeting notes, try re-authenticating by disconnecting and reconnecting.
### "No tools available" in Claude
If Jamie is connected but shows **No tools available**:
1. Go to [Customize → Connectors](https://claude.ai/customize/connectors) (must be on claude.ai, even if you use the desktop app)
2. Find the Jamie connector
3. Click the three-dot menu and choose **Remove**
4. Re-add the connector using the URL `https://mcp.meetjamie.ai/mcp` and complete authentication
### Authentication errors
Make sure you're signing in with the same email address your Jamie account is registered under. You can verify your account email in the Jamie app under **Settings → Account**.
## FAQ
No. You can use different accounts. During the OAuth flow, you'll authenticate the Jamie account you want to give access to.
No. Jamie MCP uses Dynamic Client Registration (DCR), so credentials are
created automatically. If a third-party platform shows client ID/secret
fields, leave them blank.
Yes — any tool implementing the [MCP client specification](https://modelcontextprotocol.io/) with Streamable HTTP transport can connect. Your tool needs to handle the OAuth 2.0 browser authentication flow. See the "Other AI tools" section above for details.
# Notion
Source: https://docs.meetjamie.ai/integrations/notion
Create Notion pages from your meetings
Connect Jamie to Notion to automatically create pages with your meeting summaries, transcripts, and tasks.
## Connecting Notion
1. Go to **Settings → Integrations → Notion**
2. Click **Connect Notion**
3. Click **Select Pages** and then **Allow access** (no need to change page access)
Jamie creates a database in your Notion workspace to store meeting notes.
Do not delete the database that Jamie creates. This will break the integration.
## Sending Meetings to Notion
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to Notion**
The meeting is added to your Jamie database in Notion.
## Automatic Sync
Enable **Automatic sync** to send every meeting to Notion automatically after processing completes. Toggle this in **Settings → Integrations → Notion**.
## Settings
![Notion Settings]()
Configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full meeting transcript |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# OneNote
Source: https://docs.meetjamie.ai/integrations/onenote
Save meeting notes to OneNote
Connect Jamie to OneNote to automatically save meeting notes to your notebooks.
## Connecting OneNote
1. Go to **Settings → Integrations → OneNote**
2. Click **Connect OneNote**
3. Select your Microsoft account and authorize the connection
Once connected, you can save meeting notes into any section across your existing notebooks.
## Sending Meetings to OneNote
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to OneNote**
4. Search across your notebooks and choose the **section** where you want to save the meeting
The meeting is added as a new page in the section you select.
## Automatic Sync
Enable **Automatic sync** to send every meeting to OneNote automatically after processing completes. Toggle this in **Settings → Integrations → OneNote**.
When automatic sync is on, pick a **default section**. Every meeting is then saved as a new page in that section.
## Settings
![Onenote Settings]()
Configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full meeting transcript |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# Getting Started
Source: https://docs.meetjamie.ai/integrations/overview
Connect Jamie to your favorite tools
Jamie integrates with the tools you already use, making it easy to sync meeting notes, update your CRM, and keep your team in the loop.
## CRM Integrations
Automatically log meeting notes to your CRM. Keep your sales records up to date without manual data entry.
Log meetings to contacts, companies, and deals in HubSpot
Attach meeting notes to opportunities, accounts, and contacts
Save meeting notes to leads, contacts, opportunities, and accounts
Sync meeting notes with your Attio workspace
## Note-Taking Integrations
Export your meeting notes to your preferred documentation tool. Keep everything organized in one place.
Create Notion pages with your meeting summaries and transcripts
Export meetings to Google Docs for editing and collaboration
Save meeting notes directly to your OneNote notebooks
## Task Management
Turn action items from your meetings into tasks in your project management tool.
Create Asana tasks from meeting action items and keep projects moving
## How Integrations Work
### Connecting an Integration
1. Go to **Settings → Integrations**
2. Select the integration you want to connect
3. Click **Connect** and follow the authorization flow
4. Configure your preferences
### Sharing to Integrations
![Integrations Card]()
Once connected, you can share meetings to integrations in two ways:
* **Manual sharing** — Click **Share** on any meeting, go to the **Integrations** tab, and select where to send it
* **Automatic sync** — Enable auto-sync in integration settings to automatically send all new meetings
### Managing Integrations
You can manage your integrations at any time in **Settings → Integrations**:
* **View connection status** — See which integrations are connected
* **Configure settings** — Choose what content to sync (summary, transcript, tasks)
* **Disconnect** — Remove an integration when you no longer need it
## What Gets Synced
Each integration lets you choose what content to include:
| Content | Description |
| -------------- | --------------------------------------- |
| **Summary** | AI-generated meeting notes |
| **Transcript** | Full word-for-word transcript |
| **Tasks** | Action items extracted from the meeting |
Not all integrations support all content types. Check individual integration pages for details.
# Salesforce
Source: https://docs.meetjamie.ai/integrations/salesforce
Attach meeting notes to Salesforce records
Connect Jamie to Salesforce to log meeting notes as Notes on Leads, Contacts, Opportunities, and Accounts.
Salesforce integration requires a **Pro**, **Team**, or **Enterprise** plan.
## Admin Setup (One-Time)
A Salesforce admin must complete this setup before users can connect:
1. Go to **Settings → Integrations → Salesforce** and click **Connect Salesforce**
2. Log in with an admin account and click **Allow**
3. In Salesforce, go to **Setup → Apps → Connected Apps → Manage Connected Apps**
4. Find **Jamie** and click **Install**
5. Click **Edit Policies**
6. Under **Permitted Users**, select **All users may self-authorize**
7. Click **Save**
Your Salesforce org must have the **Notes** feature enabled. Verify at **Setup → Feature Settings → Sales → Notes Settings**.
## User Setup
After admin setup, each user can connect:
1. Go to **Settings → Integrations → Salesforce**
2. Click **Connect Salesforce**
3. Log in with your Salesforce account and click **Allow**
## Sending Meetings to Salesforce
![Integrations Card]()
1. Open a meeting in Jamie
2. Click the **Share** button
3. Select **Send to Salesforce**
4. Search for a Lead, Contact, Opportunity, or Account
5. Click **Send**
Your meeting notes appear in the **Notes** section of the selected record.
If you don't see the Notes section on a record, ask your admin to add it via **Setup → User Interface → Lightning App Builder**.
## Settings
![Salesforce Settings]()
Configure what content to include:
| Option | Description |
| -------------- | ------------------------------------ |
| **Summary** | Meeting notes with executive summary |
| **Transcript** | Full transcript |
| **Tasks** | Action items from the meeting |
At least one option must be enabled.
# Connectors
Source: https://docs.meetjamie.ai/workflows/connectors
Connect the tools your workflows use: Notion, your CRM, and more
Connectors give workflows (and Jamie's chat) access to your tools. Most connectors are personal: you authorize them with your own account, and workflows can only do what your account can do. A few are workspace connectors, set up once by an admin and shared by everyone in the workspace.
## Connect a tool
1. Open [**Workflows → Connectors**](https://app.meetjamie.ai/workflows)
2. Find the tool and click **Connect**
3. Authorize Jamie in the popup. You sign in on the tool's own page, and Jamie never sees your password
4. Once connected, the row shows the tools Jamie can now use, with a toggle to enable or disable them
If your browser blocks the authorization popup, allow popups for
app.meetjamie.ai and try again.
You can also connect mid-conversation: when a workflow needs a tool you haven't connected, the builder chat offers to connect it on the spot.
## Available connectors
Connectors come in two kinds:
* **Personal connectors.** You connect them yourself, either by signing in to the tool with your own account or by pasting your own API key. Only you can see and use them, and workflows can only do what your account can do.
* **Workspace connectors.** A workspace admin connects them once, and every member's workflows and chats can use them. Affinity and Blockbrain work this way.
Most connectors use sign-in. Streak and Blockbrain use an API key instead, which you paste when you connect.
Some of the tools you can connect today:
![Notion]()
Notion
![Linear]()
Linear
![Slack]()
Slack
![GitHub]()
GitHub
![Attio]()
Attio
![Affinity]()
Affinity
![Carta]()
Carta
![OneDrive]()
OneDrive
+
And more
This is a selection, and new connectors are added regularly. The list in [**Workflows → Connectors**](https://app.meetjamie.ai/workflows) shows everything available to your workspace. GitHub and Slack are rolling out and may not appear in your list yet, and admins can turn individual connectors off for their workspace.
Missing a tool you'd like to use? Contact us at
[support@meetjamie.ai](mailto:support@meetjamie.ai) and we'll look into
adding it.
## Webhooks
Workflows can also deliver to your own systems. Add a webhook connector with a URL, and workflows can POST JSON payloads to it. This works with Zapier, Make, or anything custom. See the [webhooks documentation](/developers/webhooks/webhooks) for payload details and security.
## Disconnecting
Click a connected tool and choose **Disconnect**. Workflows that relied on it will report that the connector is missing on their next run instead of failing silently.
# Workflows
Source: https://docs.meetjamie.ai/workflows/overview
Automate what happens after your meetings — log CRM activities, update records, send notes
A workflow runs automatically after your meetings. You describe what should happen — "log a call activity in my CRM with the key takeaways", "post a summary to the deal channel" — and Jamie does it for every meeting that matches, using the tools you've connected.
Workflows are rolling out gradually. If you don't see **Workflows** in your
sidebar yet, it hasn't been enabled for your workspace.
## Create a workflow
1. Open [**Workflows**](https://app.meetjamie.ai/workflows) from the sidebar
2. Describe what you want in the chat — for example: *"After every external meeting, create a note in Notion with the summary and action items"*
3. Jamie drafts the workflow and asks follow-up questions where it needs detail — which connector to use, which meetings it should run for
4. Test it on a recent meeting before turning it on: *"Test it on my most recent meeting"*
Your chats are saved — refresh the page and the conversation resumes, and **Previous chats** in the top bar restores older ones.
## When workflows run
| Trigger | What it means |
| ------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Automatic** | Runs after every meeting that matches the workflow's conditions (for example, only meetings with external attendees) |
| **Manual** | You start it yourself with **Run on…** from the workflow list, picking the meeting |
| **Test** | A trial run from the builder chat while you're refining the workflow |
## Runs and results
Every run produces a one-line result describing what happened ("Created Salesforce activity…"). You'll find runs in two places:
* **The Workflows page** — expand any workflow to see its run history
* **The meeting page** — the workflows panel shows what ran for that meeting, live while it's running
Click any run to see the full trace of what Jamie did, step by step. Runs stream live while in progress.
## Approvals
By default, automatic runs don't write to your external tools. Instead, Jamie does a dry run, collects the actions it *would* take, and pauses with **Waiting for your approval**. Review the run and click **Approve & run** — Jamie then executes exactly the actions you saw, nothing more.
Once you trust a workflow, you can allow it to write automatically without approval — Jamie will suggest this in the builder chat, or you can ask for it directly.
## Manage workflows
Click a workflow to open its details:
* **Active toggle** — pause a workflow without deleting it
* **Instructions** — edit inline, or click **Edit in chat** to refine it conversationally
* **History** — every run, newest first
## Next steps
Workflows use connectors to reach your tools — Notion, your CRM, and more.