# Set up your client

> Add June MCP to Claude Code, Codex, Cursor, OpenCode or any client that adds remote MCP servers with a sign-in, then sign in with your June account.

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

Set up June once in each client, then check that it can list your integrations before asking it to do work. Every client needs the same two things: June's address, and a sign-in with your June account in your browser. Each client, and each computer, signs in on its own.

The client uses the integrations in your personal space, never an organization's. With several June accounts, sign in with the one that holds them.

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

**Claude Code**

1. Add June for all your projects:
   ```bash
   claude mcp add --transport http --scope user june https://www.dearjune.ai/api/mcp
   ```
   `--scope user` keeps it in `~/.claude.json`, for every project on this computer. Without `--scope`, June is added to the current project only. `--scope project` writes it to the repository's `.mcp.json`, for everyone who works there; each of them signs in with their own June account.
2. Sign in:
   ```bash
   claude mcp login june
   ```
   Or, inside Claude Code, run `/mcp`, pick `june` and authenticate. Your browser opens June's sign-in; sign in with your June account.
3. Check it: `claude mcp list` shows `june` with `✔ Connected`, or `! Needs authentication` until you sign in. Then ask Claude Code to list your June integrations.

**Codex**

1. Add June:
   ```bash
   codex mcp add june --url https://www.dearjune.ai/api/mcp
   ```
   Codex keeps it in `~/.codex/config.toml`, which the Codex command line, the ChatGPT desktop app and the editor extension share.

   Codex gives up on a tool after 60 seconds, the same as June's run limit, so a slow answer can be cut off on Codex's side first. `approval` waits 50 seconds for your decision by default, which fits; a longer timeout is needed only when the client asks it to wait more than 60 seconds (`waitSeconds`, up to 300). To give it room:
   ```toml
   [mcp_servers.june]
   url = "https://www.dearjune.ai/api/mcp"
   tool_timeout_sec = 120
   ```
2. Sign in:
   ```bash
   codex mcp login june
   ```
   Your browser opens June's sign-in; sign in with your June account. On a computer without a browser, add `--no-browser`, open the address it prints elsewhere and paste back the address you land on.
3. Check it: `codex mcp list` shows `june`, and so does `/mcp` inside Codex. Then ask Codex to list your June integrations.

**Cursor**

1. Add June to `~/.cursor/mcp.json` for every workspace, or to `.cursor/mcp.json` in one project:
   ```json
   {
     "mcpServers": {
       "june": {
         "url": "https://www.dearjune.ai/api/mcp"
       }
     }
   }
   ```
2. When Cursor asks, sign in with your June account in the browser window it opens.
3. Check it: `june` shows, switched on, on Cursor's Customize page. Then ask Cursor's chat to list your June integrations.

**OpenCode**

1. Add June to `~/.config/opencode/opencode.json` for every project, or to `opencode.json` at a project's root:
   ```json
   {
     "$schema": "https://opencode.ai/config.json",
     "mcp": {
       "june": {
         "type": "remote",
         "url": "https://www.dearjune.ai/api/mcp"
       }
     }
   }
   ```
2. Sign in:
   ```bash
   opencode mcp auth june
   ```
   Your browser opens June's sign-in; sign in with your June account. OpenCode also asks on its own the first time it uses June.
3. Check it: `opencode mcp list` shows `june` and whether it is signed in. Then ask OpenCode to list your June integrations.

**Another client**

Any client works that adds a remote MCP server by its address over HTTP and signs in with OAuth, registering itself with the sign-in or naming itself by a client metadata address. Paste the address above as the server URL, and sign in with your June account when the client opens your browser.

There is no key or client ID to paste, so a client that only accepts one cannot connect. Neither can a client that only speaks the older SSE transport, or one that runs inside a web page and calls the server from your browser.

## If the check fails

- **Not signed in, or needs authentication:** sign in again with the step above.
- **Signed in with the wrong June account:** sign out, with `claude mcp logout june`, `codex mcp logout june` or `opencode mcp logout june`, then sign in again with the right one.
- **June lists nothing:** check that you signed in to the intended June account, then connect your tools on the **Integrations** page in your personal space. Connections made inside an organization are not available through June MCP.

## Stop a client

Sign a client out to keep June set up in it, ready for the next sign-in; remove June to delete it from the client.

| Client      | Sign out                                | Remove                             |
| :---------- | :-------------------------------------- | :--------------------------------- |
| Claude Code | `claude mcp logout june`                | `claude mcp remove june`           |
| Codex       | `codex mcp logout june`                 | `codex mcp remove june`            |
| OpenCode    | `opencode mcp logout june`              | delete `june` from `opencode.json` |
| Cursor      | switch `june` off on the Customize page | delete `june` from `mcp.json`      |

June checks the sign-in on every request but keeps no list of the clients signed in to it, so it cannot sign one out for you. If you lose a computer with a signed-in client, sign it out there if you still can; if not, ask [support](/docs/support).

## What June does not do

- It does not list your clients or show which ones are signed in.