# How do we connect Outlook to Claude for every employee?

> To connect Outlook to Claude for every employee, give each person their own connection so Claude reaches only their mailbox. IT picks read, draft or send.

**TL;DR** To connect Outlook to Claude for every employee, have each person connect Elaichi's Outlook Mail connector with their own Microsoft sign-in, so Microsoft Graph treats each call as that person and their mailbox. A shared connection runs on one credential for everyone, and an app-only one can reach every mailbox. Elaichi role rules then decide whether each team may read, draft or send.

## Why connect Outlook to Claude one mailbox per person?

A mailbox holds every private thread a person has, so Claude should open only the mailbox of whoever is asking. Jake Morgan runs IT at a 300-person company that is rolling out Claude. The first request comes from finance: can Claude read Outlook and draft replies? Priya Shah should see Priya's mail, and never the CFO's. Jake also has to decide whether Claude may send mail at all, or only draft it. To connect Outlook to Claude for a whole company, settle those two questions first. Whose mailbox does each call reach, and which mail actions does each role keep?

MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps. Elaichi gives Claude, ChatGPT, Cursor and Microsoft Copilot one MCP address, `https://api.elaichi.ai/mcp`. Behind it, [Elaichi's Outlook Mail connector](/connectors/outlook/) calls Microsoft Graph, Microsoft's API for mail and other Microsoft 365 data. The connector signs in one of two ways: OAuth as a person, or OAuth client credentials as an app. That choice decides whose mail a call can reach.

## Delegated or application access: what Microsoft Graph decides

Microsoft Graph sets the outer wall. With delegated access, an app acts for a signed-in user and cannot reach anything that user could not reach. With app-only access, the app uses its own identity and no user signs in ([Microsoft Learn: permissions overview](https://learn.microsoft.com/en-us/graph/permissions-overview), checked November 2026). Microsoft's client credentials page says an app signing in as itself must use application permissions ([Microsoft Learn: client credentials flow](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-client-creds-grant-flow), checked November 2026).

The mail permissions show how far apart the two are. This table follows the [Graph permissions reference](https://learn.microsoft.com/en-us/graph/permissions-reference) (checked November 2026).

| Permission | Delegated reach | Application reach | Admin consent required |
|---|---|---|---|
| Mail.ReadBasic | The signed-in user's mail, without body, preview or attachments | The same fields in all mailboxes | Application only |
| Mail.Read | The signed-in user's mailbox | All mailboxes | Application only |
| Mail.ReadWrite | Create, read, update and delete mail, without sending | The same in all mailboxes | Application only |
| Mail.Send | Send mail as a user | Send mail as any user | Application only |

Read and send are separate grants. The [permissions reference](https://learn.microsoft.com/en-us/graph/permissions-reference) notes that Mail.Send can send and save a copy to Sent Items without Mail.ReadWrite (checked November 2026). Microsoft's list-messages reference names two cases: the app holds application permissions, or the other person shared a folder or gave delegate access ([Microsoft Learn: list messages](https://learn.microsoft.com/en-us/graph/api/user-list-messages?view=graph-rest-1.0), checked November 2026).

## One Outlook connection per person, or one shared connection?

Per person is the shape for "only their own mailbox". Each employee connects the outlook connector with their own Microsoft sign-in and leaves it unshared. Every call through a connection uses that connection's credential, so Priya's calls run as Priya in Graph. She reaches her mailbox and anything already delegated to her, and nothing else.

To save setup, share a template at `use`. A template is a named list of tool entries that stores no connection. Each employee stamps their own toolbox from it and picks their own Outlook connection. A single toolbox shared with the team cannot do this, because its entries run only on the connection pinned in them.

The message tools take a required `user_id`, and the model fills it in. To keep it on the caller's own mailbox, lock `user_id` in the template's entries to the caller's email, the per-person value `caller.email`. Each stamped toolbox copies the lock. Graph names a mailbox by user id or user principal name ([Microsoft Learn: list messages](https://learn.microsoft.com/en-us/graph/api/user-list-messages?view=graph-rest-1.0), checked November 2026). So the lock works where each person's email matches their sign-in name.

Two shared shapes go wrong in different ways. A shared OAuth connection runs on its owner's sign-in for everyone. If Jake connects Outlook and shares it at `use`, every teammate reads Jake's inbox and sends as Jake. A shared client-credentials connection uses application permissions. With application Mail.Read and Mail.Send, it can read every mailbox and send as any user ([Microsoft Learn: permissions reference](https://learn.microsoft.com/en-us/graph/permissions-reference), checked November 2026). Most of the connector's message tools take a required `user_id`, so the model picks whose mailbox to open.

If a company still wants the app route, two controls narrow it. The same `caller.email` lock goes on a toolbox entry, and in Elaichi, a freeze binds only calls made through its toolbox entry, so share the toolbox with the people it governs, not the connection itself. A caller with no value is refused before anything reaches Microsoft. Leave out tools with no `user_id`, such as `outlook_messages_forward`, because nothing locks their mailbox. The lock also binds only calls made through that toolbox entry. The connection's owner still reaches every mailbox, unlocked, through their own All tools toolbox.

Microsoft does not see that lock: to Graph, every call is the app. Exchange RBAC for Applications can limit the app to a set of mailboxes on Microsoft's side. Microsoft warns that a scoped grant adds to any unscoped Entra grant, so remove the Entra grant. Changes there take 30 minutes to 2 hours ([Microsoft Learn: RBAC for Applications](https://learn.microsoft.com/en-us/exchange/permissions-exo/application-rbac), checked November 2026).

## Which Outlook tools read, and which ones act

The connector's mail reads cover messages, folders, search and attachments. The tools that draft, send, reply, forward, move or delete change a mailbox or reach people outside it. Elaichi tiers each tool as read, write or destructive.

| What it does | Example tools | Elaichi tier |
|---|---|---|
| Read mail and folders | `list_all_outlook_messages`, `get_single_outlook_message_by_id`, `list_all_outlook_folder_messages`, `list_all_outlook_mail_folders`, `list_all_outlook_search` | Read |
| Read attachments | `list_all_outlook_attachments`, `outlook_attachments_download` | Read |
| Draft | `create_a_outlook_message`, `update_a_outlook_message_by_id` | Write |
| Send | `outlook_messages_send_mail`, `outlook_messages_send_draft` | Write |
| Reply and forward | `outlook_messages_reply`, `outlook_messages_reply_all`, `outlook_messages_forward`, `outlook_messages_forward_as_user` | Write |
| File mail | `outlook_messages_move`, `create_a_outlook_mail_folder` | Write |
| Delete | `delete_a_outlook_message_by_id`, `delete_a_outlook_mail_folder_by_id`, `delete_a_outlook_child_folder_by_id` | Destructive |
| Notifications | `create_a_outlook_subscription` | Write |

A reply is not a safer send. The reply tool, `outlook_messages_reply`, accepts recipients that add to or override the original ones, so a reply can go anywhere. The draft tool, `create_a_outlook_message`, only creates a draft, and `outlook_messages_send_draft` sends it. The subscription tool posts change notifications to a URL the caller supplies, so restrict it for every mail role. The directory tool, `list_all_outlook_users`, lists the company's users rather than any mailbox.

Mail is text from outside the company, and a message can carry instructions aimed at the model. Elaichi's MCP endpoint is not protected against injected instructions. What the rules control is what a poisoned email could trigger. With send, reply and forward restricted, reading a message cannot become an outbound Outlook message through Elaichi.

## How does IT choose read, draft or send for each role?

IT writes the choice as restrictions on roles. A restriction is a rule naming which connectors and which individual tools a target may reach. In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. Each member holds exactly one role, so the mail tier follows the role.

**Read only.** Write an allow rule naming the read tools above. In Elaichi, once a role carries any allow rule, every connector and tool none of its allow rules names is blocked for that role. So the same rule, or a second allow rule on the role, must name every other app the team uses as whole connectors.

**Draft.** Add `create_a_outlook_message` and `update_a_outlook_message_by_id` to the allow rule, and nothing that sends.

**Send.** Allow the send, reply and forward tools as well, `outlook_messages_forward` included. Keep block rules on the delete tools and `create_a_outlook_subscription`. Within a layer, a block always beats an allow, so a later widening of the allow rule leaves them restricted.

Block rules alone work differently. In Elaichi, a layer with only block rules has no allowlist, so everything it does not block passes it. A block-only read tier must name every Outlook tool that is not a read. Any role or restriction change takes effect within about two minutes. [Per-tool versus per-app rules](/blog/per-tool-vs-per-app-restrictions/) compares the two shapes.

When Priya later needs to send, she files an access request. An admin approves it in the console under Governance, then Access requests. The grant lifts that one tool for her alone, and her role is not edited.

## Who approves the Microsoft consent?

For per-person sign-in, the tenant's consent settings decide. Microsoft says users can, by default, consent to permissions that need no administrator, such as access to their own mailbox ([Microsoft Learn: configure user consent](https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/configure-user-consent), checked November 2026). Tenant consent policies can still restrict that ([Microsoft Learn: permissions overview](https://learn.microsoft.com/en-us/graph/permissions-overview), checked November 2026).

Where users cannot consent, an Entra admin grants tenant-wide consent. A Privileged Role Administrator can do it for any permission. A Cloud Application Administrator, AI Administrator or Application Administrator can too, except for Graph application permissions. Tenant-wide consent opens the app to all users, unless the admin requires user assignment and assigns chosen users or groups ([Microsoft Learn: grant admin consent](https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/grant-admin-consent), checked November 2026).

The app route always needs an admin. Only a Privileged Role Administrator or Global Administrator can consent to application permissions ([Microsoft Learn: permissions overview](https://learn.microsoft.com/en-us/graph/permissions-overview), checked November 2026). Which permissions the connector's own sign-in asks for is shown on the consent screen, so have the Entra admin read it there. [When Claude says admin approval is required](/blog/claude-admin-approval-required-microsoft-365/) covers what to send that admin.

## Test the rollout from one employee's account

Test from a member account on each role before announcing anything. Add the endpoint in Claude by following [the Elaichi setup guide for Claude](/blog/connect-elaichi-to-claude/). Each person signs in with their own OAuth grant, the browser approval that ties their Elaichi identity to that client. Then, as a read-only member, ask for this morning's unread mail.

Next, search for "send" and "forward". A restricted tool is left out of the tools Elaichi offers a client and cannot be called. Search still names it, flagged restricted, with no schema. Then ask for a colleague's mailbox by address. Through a stamped toolbox, the lock keeps `user_id` on the caller's own mailbox. Through the All tools toolbox, Graph should refuse unless that colleague shared a folder or gave delegate access ([Microsoft Learn: list messages](https://learn.microsoft.com/en-us/graph/api/user-list-messages?view=graph-rest-1.0), checked November 2026).

Then read the audit trail. Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none). In Elaichi, a call from an MCP client is recorded under the person who signed in, with surface `mcp` and the OAuth client named. Each entry also keeps the one path argument that names the object, as the target id, and nothing else about the arguments.

Offboarding stays simple with per-person connections. In Elaichi, a private connection that nothing beyond the member depends on cannot be transferred and is deleted with them. Also in Elaichi, removing or suspending a member revokes every live grant in the same transaction as the membership change. The person's Claude then fails on its next call.

## When Claude's own Microsoft 365 connector is enough

If Claude is the only AI client and Outlook is the main app, Anthropic's own connector may be enough. Its Microsoft 365 connector covers Outlook, SharePoint, OneDrive and Teams on every Claude plan. It uses delegated permissions and is read-only by default. Its write tools send email and manage drafts. They use an updated permission set that includes Mail.Send and Mail.ReadWrite. An admin sets each one to Always allow, Needs approval or Blocked ([Anthropic: set up the Microsoft 365 connector](https://support.claude.com/en/articles/12542951-set-up-the-microsoft-365-connector), checked November 2026).

Elaichi earns its place when the answer must hold across clients and apps. One endpoint serves Claude, ChatGPT, Cursor and Microsoft Copilot. One set of role rules covers Outlook beside the CRM and the help desk, and one audit trail shows who asked what. The same per-person pattern for Google mail is in [Gmail and Calendar for ChatGPT](/blog/connect-gmail-and-google-calendar-to-chatgpt/). For one person trying a few prompts, [a control plane can wait](/blog/when-you-dont-need-an-mcp-gateway/). Browse the [900+ connectors](/connectors/) for the rest of the stack.

## FAQ

### Can one Outlook connection give Claude every employee's mailbox?

Only if it uses Microsoft Graph application permissions. Microsoft's permissions reference says application Mail.Read reads mail in all mailboxes and application Mail.Send sends mail as any user (checked November 2026). A connection made with one person's sign-in reaches that person's mailbox, plus folders others shared with them. For "each person sees only their own mail", give each employee their own connection.

### Does each employee need an admin to approve their Outlook sign-in?

It depends on the tenant. Microsoft says that by default users can consent to permissions that do not need an administrator, such as letting an app reach their own mailbox. Its permissions reference marks the delegated Mail.Read, Mail.ReadWrite and Mail.Send permissions as not needing admin consent (checked November 2026). It also depends on which permissions the connector's consent screen requests, and tenant consent policies can still restrict user consent. Then an Entra admin grants consent.

### Can Claude draft Outlook emails without sending them?

Yes, if the role's rules allow the draft tool and restrict the send tools. In Elaichi's Outlook Mail connector, create_a_outlook_message creates a new draft, not a threaded reply, and outlook_messages_send_draft, outlook_messages_send_mail, the reply tools and the forward tools send. An allow rule that names the reads, create_a_outlook_message and update_a_outlook_message_by_id, and not the send tools, gives a role drafts only. The person then sends from Outlook.

### Is Claude's own Microsoft 365 connector enough for Outlook?

For a Claude-only rollout it can be. Anthropic's Microsoft 365 connector covers Outlook, SharePoint, OneDrive and Teams on every Claude plan, uses delegated permissions and is read-only by default, with per-tool settings for write tools (checked November 2026). Elaichi fits when the same rules and audit trail must cover ChatGPT, Cursor or Microsoft Copilot as well, or Outlook beside other apps.

### How fast does a new Outlook restriction take effect in Elaichi?

A restriction change in Elaichi takes effect within about two minutes, so wait that long before testing a new rule. Revoking a share is faster: in Elaichi, revoking a share or disconnecting an account takes effect on the caller's next call.

## Read next

- [Claude admin approval required for Microsoft 365](/blog/claude-admin-approval-required-microsoft-365/) — Claude admin approval required for Microsoft 365 is Entra consent. No safe workaround exists: an admin grants it. Here is who, how, and what to send.
- [Gmail and Calendar MCP access for ChatGPT](/blog/connect-gmail-and-google-calendar-to-chatgpt/) — Gmail and Calendar MCP access for ChatGPT: each person signs in as themselves, and restrictions stop the AI sending or deleting mail.
- [Microsoft Teams MCP access for ChatGPT: a playbook](/blog/connect-microsoft-teams-to-chatgpt-for-our-company/) — Microsoft Teams MCP access for ChatGPT: pick the route, set restrictions on the Microsoft apps around it, then prove them in the audit log.
