# Use June from any MCP client

> Add June MCP to Claude Code, Codex, Cursor or another MCP client, and it can use the integrations you connected in June, without connecting them again.

Source: https://www.dearjune.ai/docs/june-mcp

Connect Gmail, GitHub or Notion once in June, and Claude Code, Codex or Cursor can use them, with no keys or sign-ins of their own.

It reaches the integrations in your personal space, never an organization's. The client can also read your threads with June and, once you allow it, act in them: send a message, stop June or start a thread. It gets no memory and no schedules.

The address is the same for every MCP client:

```text
https://www.dearjune.ai/api/mcp
```

[Set up your client](/docs/june-mcp/clients) has the command or file for each one, and how to sign in with your June account.

## What the client gets

Three tools for your integrations, not one per integration:

- `skills` tells the client how to write a program for `execute`, lists the integrations you have connected, and names the MCP servers you added but have not signed in to.
- `execute` runs a short program on June's side. The program finds the tools it needs among your integrations, calls them and returns the result to the client.
- `approval` tells the client how a step you were asked to approve ended: it waits for your decision and says whether the step ran, was denied or expired. It never runs anything itself.

Tools for your threads. These read, and every client may use them:

- `thread_list` lists your threads and your organizations' chats, newest first, by project, organization or title.
- `thread_read` reads one thread's messages: what people wrote and June's replies, without June's steps.
- `thread_search` searches your threads, from the web and from Slack, for up to 30 matches.
- `queue_list` and `queue_read` show the messages agents queued in a thread.
- `thread_wait` waits up to 10 minutes for June's reply in a thread to end, or for a step there to need your approval.
- `task_status` reads a task the client handed off: whether it is still working and, once it is done, its result.

These act as you, and only a client you allowed may use them:

- `thread_send` sends a message into a thread. With `auto` it starts June or updates the reply it is writing, with `queue` it waits until June is free there, with `steer` it updates its reply, and with `restart` it stops its reply and goes next.
- `thread_interrupt` stops June in a thread, as your Stop does.
- `queue_edit`, `queue_cancel`, `queue_promote_to_steer` and `queue_reorder` change, remove, send now or move a message an agent queued.
- `thread_launch` starts a thread in your own chats, a project or an organization, with a title and its first message.
- `delegate_task` hands a task to a new thread in your own chats. The thread sees only the task. With `wait`, the client waits up to 10 minutes for the result.
- `task_cancel` stops a task the client handed off, and the tasks that task handed off.

In an organization's chats, which are multi-player, June speaks only when someone tags it. A client you allowed acts as you there: a message with `@june` in it starts June or updates its reply, as yours would, and one without it is posted for the members and does not start it. It can also stop its reply, or send a queued message now, as you could, but only in chats you can post in. There `steer` and `restart` need a message with `@june` in it.

### Allow a client to act

Every client starts out able only to read. The first time one tries to act, June refuses and the client is listed under **Connected agents** in **Settings**. To let it act, turn on **Can act on your threads** there, and ask again. Turn it off the same way. Your [approval rules](/docs/how-june-works/connections#a-step-that-needs-your-confirmation) still apply to every action: one they do not allow does not run, and the client gets a June link for it instead, as for any other step ([how](#when-a-step-needs-your-approval)). Its approval page names the thread, the message or what the action does, and the client that asks. If you turn **Can act on your threads** off before you approve, approving runs nothing.

You do not write the program yourself: you ask the client for the work, and it writes one. To write your own, see [Write June MCP programs](/docs/june-mcp/programs).

> Example prompt: Use June to list the integrations I have connected

> Example prompt: Through June, find unread mail from [accountant@acmestudio.com](mailto:accountant@acmestudio.com) from this week and list the subjects

> Example prompt: Start a June thread in my Launch project that drafts the release notes from this diff

## Which connections it reaches

June MCP reaches what you connected in your personal space, on the **Integrations** page. It never uses connections made inside an [organization](/docs/organizations). This is separate from thread access: the client can read organization chats you can read, and can act in them once you allow it.

| Connected                                                                       | Reached |
| :------------------------------------------------------------------------------ | :------ |
| In your personal space, including a connection you set to **Personal only**     | Yes     |
| An MCP server you added on the **Integrations** page, with or without a sign-in | Yes     |
| Inside an organization, including **Use work account** connections              | No      |
| An organization's MCP servers, including those that need no sign-in             | No      |

Not every integration offers the same tools here as in a chat with June:

| Integration                                                                | What a client can do                                                                                                      |
| :------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------ |
| [Mailbox](/docs/integrations/mailbox), and Outlook mail from Microsoft 365 | search and read your mail, save drafts                                                                                    |
| [Microsoft 365](/docs/integrations/microsoft-365)                          | read your calendar, Teams chats and OneDrive and SharePoint files                                                         |
| [Google Drive](/docs/integrations/google-drive)                            | search and read your files                                                                                                |
| [Google Search Console](/docs/integrations/google-search-console)          | read search performance, index status and sitemaps                                                                        |
| [GitHub](/docs/integrations/github)                                        | read your account, a repository's details and one file at a time                                                          |
| [Notion](/docs/integrations/notion)                                        | read the pages and databases you share; add pages and rows, set values, add to the end of a page                          |
| [X](/docs/integrations/x)                                                  | read posts, threads, mentions, bookmarks, likes, followers and following, and your posts' analytics                       |
| [Any MCP server](/docs/integrations/custom-mcp) you added                  | every tool the server offers; one that changes something [asks for your approval](#when-a-step-needs-your-approval) first |

Obsidian, ownCloud and Tailscale work only in June's sandbox, so a client does not reach them. GitHub's issues, pull requests and pushes go through June's sandbox too: a client reads GitHub but does not work in it.

## When a connection is missing

When a request needs an integration you have not connected, or one whose sign-in expired, the client can give you a June link. Open it, sign in to June and to the service, and ask again.

The link connects or renews only an integration's `default` connection. A connection you gave another name, such as `work`, is renewed with **Re-auth** on its row on the **Integrations** page. A mailbox added with a password, or a server added with a token, is fixed on that page too.

## When a step needs your approval

Reading never asks. A step that changes something, such as creating a Microsoft 365 calendar event, sending a Teams message, sending an email, a tool of an MCP server you added, or sending a message into one of your threads, runs only once you approve it:

1. The step does not run. The client gets a June link for it, such as `https://www.dearjune.ai/approve/…`, and gives it to you.
2. Open the link, signed in to June with the same account. The approval page shows exactly what will happen, as a card in a chat does. **Approve** runs that one step, once, as shown; when offered, **Always allow** lets this kind of step run without asking from now on, everywhere June works for you; **Deny** stops it.
3. Tell the client you decided. It asks June with `approval` and tells you whether the step ran and what it did, or that nothing ran.

- A connected agent’s request to start a thread, send a message, stop a reply or change a queue offers **Approve** or **Deny**, with no **Always allow** option. Approval covers that one call.
- Only you can approve: the link opens the card for your June account alone, and the client cannot approve for you.
- The client does not run the program again for the step: approving runs exactly the step the page showed. Running the program again asks again, with a new link.
- A step nobody decides expires after 24 hours, and nothing runs.
- A step a rule of yours or your organization blocks does not run and has no link; the client says why.
- A step you allowed with **Always allow**, here or in any chat, runs inside the program without a link. You can revoke the rule in **Settings** → **Approvals**.
- Sending a Gmail draft, and replying to, changing or cancelling a Google Calendar or Microsoft 365 event, always have a link, even when a rule allows them: on June MCP they run only from the approval page, so what runs is the draft or the event the page showed. Cancelling an event never offers **Always allow**.

## What June does not do

- It does not hand out your credentials. The program calls your integrations through June and never sees a token.
- It does not open websites, read files on your computer or run commands: a program reaches only your integrations.
- It does not run a step that needs your approval on its own: you approve it on its approval page first ([how](#when-a-step-needs-your-approval)).
- It does not let a client add, connect or remove integrations. Connect them on the **Integrations** page.
- It does not let a client act in your threads until you allow it under **Settings** → **Connected agents**.
- It does not run a program past its [limits](/docs/june-mcp/programs#limits) on size, run time and result.

## More on June MCP

- [Set up your client](/docs/june-mcp/clients): Claude Code, Codex, Cursor, OpenCode or another client.
- [Write June MCP programs](/docs/june-mcp/programs): how a program finds and calls tools, three examples, and its limits.