> ## Documentation Index
> Fetch the complete documentation index at: https://developer.zeeg.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect AI apps (MCP)

> Connect Claude, ChatGPT, Cursor, VS Code and other MCP clients to your Zeeg workspace: server URL, sign-in, the tool list, safety, and data processing.

Zeeg runs a remote [MCP](https://modelcontextprotocol.io) server, so an AI app you already use — Claude, ChatGPT, Cursor, VS Code, or any other MCP client — can read and act on your Zeeg workspace: check availability, book and reschedule meetings, look up CRM people, read routing form submissions, review AI voice agent calls, and more.

<Info>
  The MCP server is served from our own backend in Germany, the same servers and processing region as the rest of Zeeg.
</Info>

## Server URL

```
https://api.zeeg.me/mcp
```

Every MCP client listed below connects to this one URL. There's nothing to install on our side and no separate account to create — you sign in with your existing Zeeg login.

## Connect from your AI app

<Tabs>
  <Tab title="Claude (claude.ai)">
    Go to **Settings → Connectors → Add custom connector**, paste the server URL, and follow the sign-in prompt.
  </Tab>

  <Tab title="Claude Code">
    ```bash theme={null}
    claude mcp add --transport http zeeg https://api.zeeg.me/mcp
    ```
  </Tab>

  <Tab title="ChatGPT">
    Turn on developer mode (or open **Connectors**) and add a new connector with the server URL above.
  </Tab>

  <Tab title="Cursor">
    Add a `zeeg` entry to `.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "zeeg": {
          "url": "https://api.zeeg.me/mcp"
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    Add the same shape to `.vscode/mcp.json`:

    ```json theme={null}
    {
      "servers": {
        "zeeg": {
          "type": "http",
          "url": "https://api.zeeg.me/mcp"
        }
      }
    }
    ```
  </Tab>
</Tabs>

## Sign-in and consent

The first tool call opens your browser to Zeeg. If you're not signed in, you'll see sign-in and create-account buttons; sign in or sign up, and you're sent straight back to finish connecting.

You'll then see a Zeeg-branded consent page naming the app, the redirect it will use, the workspace you're connecting, and what it will be able to do. Approve it, and the app acts with **your own dashboard permissions** — a member sees what they see in the dashboard, an admin sees the whole workspace. It can't do anything you can't already do yourself.

Manage or revoke a connection any time from **Settings → Connected apps**, which also shows every tool call the app has made.

## Plan requirement

MCP access needs a **trial or paid** Zeeg plan. On a free plan, every tool returns a plain error explaining that MCP needs a paid plan or an active trial, with a link to billing — never a bare 401 or 403.

Some tools need more than base access:

* `find_available_times` and `book_meeting` need a **paid** plan (not trial) — the same premium-scope check the public API applies to available-time and booking-creation requests.
* The voice agent tools (`list_voice_agents`, `list_agent_calls`, `get_agent_call` and `start_outbound_call`) need **AI minutes** in the workspace: an AI minutes subscription or enough AI credit.

## Tools

Tool names are `snake_case`; every tool declares a title and whether it's read-only or destructive, which AI apps use to decide when to ask you before calling it.

| Area          | Tool                     | Does                                                                    | Plan           |
| ------------- | ------------------------ | ----------------------------------------------------------------------- | -------------- |
| Account       | `get_me`                 | Signed-in user, workspace, plan status, and teammates                   | Trial/paid     |
| Event types   | `list_event_types`       | List your scheduling pages                                              | Trial/paid     |
| Event types   | `get_event_type`         | Get one scheduling page's details                                       | Trial/paid     |
| Event types   | `create_single_use_link` | Create a one-time booking link for a scheduling page                    | Trial/paid     |
| Event types   | `set_event_type_active`  | Turn a scheduling page on or off                                        | Trial/paid     |
| Availability  | `find_available_times`   | Find open slots for a scheduling page                                   | **Paid**       |
| Availability  | `get_schedules`          | List working-hours schedules                                            | Trial/paid     |
| Availability  | `update_schedule`        | Change a working-hours schedule                                         | Trial/paid     |
| Availability  | `add_time_off`           | Block out days as unavailable                                           | Trial/paid     |
| Bookings      | `list_bookings`          | List scheduled meetings                                                 | Trial/paid     |
| Bookings      | `get_booking`            | Get one meeting's details                                               | Trial/paid     |
| Bookings      | `book_meeting`           | Book a meeting                                                          | **Paid**       |
| Bookings      | `reschedule_booking`     | Move a meeting; finds valid times itself when you pass none             | Trial/paid     |
| Bookings      | `cancel_booking`         | Cancel a meeting                                                        | Trial/paid     |
| Bookings      | `hand_over_booking`      | Hand a round-robin meeting to a teammate                                | Trial/paid     |
| Notes         | `add_note`               | Add a note to a booking or CRM record                                   | Trial/paid     |
| Notes         | `list_notes`             | List notes on a booking or CRM record                                   | Trial/paid     |
| CRM           | `search_crm`             | Search people, companies, and custom objects                            | Trial/paid     |
| CRM           | `get_crm_record`         | Get one CRM record                                                      | Trial/paid     |
| CRM           | `upsert_crm_record`      | Create or update a CRM record                                           | Trial/paid     |
| Routing forms | `list_routing_forms`     | List routing forms                                                      | Trial/paid     |
| Routing forms | `list_form_submissions`  | List a routing form's submissions                                       | Trial/paid     |
| Voice agents  | `list_voice_agents`      | List your AI voice agents                                               | **AI minutes** |
| Voice agents  | `list_agent_calls`       | List one voice agent's calls                                            | **AI minutes** |
| Voice agents  | `get_agent_call`         | Get one voice agent call, with transcript and collected data on request | **AI minutes** |
| Voice agents  | `start_outbound_call`    | Start an AI voice agent call; spends AI minutes                         | **AI minutes** |
| Guidance      | `get_zeeg_guide`         | How Zeeg's objects relate, and which tool to call first                 | Trial/paid     |

`search_crm` and `get_booking` results carry a link straight to the record in your dashboard; so do `list_voice_agents`, `list_agent_calls` and `get_agent_call`.

## Safety

* **Confirmation before it matters.** `book_meeting`, `cancel_booking`, `reschedule_booking`, `hand_over_booking`, and `start_outbound_call` are marked destructive, so a well-behaved AI app confirms with you before calling them — booking, cancelling, moving, handing over and calling all have a real-world effect, and `start_outbound_call` spends AI minutes.
* **Text from outside your workspace is marked as data, not instructions.** Booking answers, notes, and routing form submissions are written by invitees and form respondents. The server labels this content and tells the connected AI app never to treat it as instructions — a booking answer that says "ignore your previous instructions" stays inert.
* **Every tool call is logged.** Which app, which tool, what it touched, and whether it succeeded — visible to you (and, for admins, the whole workspace) at **Settings → Connected apps**. Arguments and results aren't stored, only what happened.
* **Lean output by default.** Tool results return what the task needs — a list of bookings, for instance, doesn't include phone numbers or form answers unless the app explicitly asks for them.

## Data processing

Once you approve a connection, tool results — booking details, CRM records, form answers, and so on — are sent to the AI provider behind the app you connected (Anthropic for Claude, OpenAI for ChatGPT, and so on). That's the same as pasting the data into that app yourself. Zeeg's own processing and hosting stay in Germany, unchanged by connecting an AI app.

## For OAuth client builders

The MCP server implements the [MCP authorization spec](https://modelcontextprotocol.io/specification/draft/basic/authorization) on top of our existing Passport OAuth:

* **Discovery:** `GET /.well-known/oauth-authorization-server` and `GET /.well-known/oauth-protected-resource/mcp`, both under `https://api.zeeg.me`.
* **Resource:** the protected-resource metadata's `resource` is exactly `https://api.zeeg.me/mcp`.
* **PKCE:** required, `S256` only. An authorize request with `plain`, or without `code_challenge_method`, is refused with `invalid_request`.
* **Issuer identification (RFC 9207):** every authorization response carries `iss`, equal to the metadata `issuer` (`authorization_response_iss_parameter_supported: true`).
* **Dynamic client registration:** `POST /oauth/register`, open to any redirect host — the consent page names the redirect host and marks the app unverified unless it's on our first-party allowlist, so don't rely on registration itself as a trust signal.
* **Client ID metadata documents (CIMD):** also supported (`client_id_metadata_document_supported: true`), and preferred over DCR for a high-traffic client — the metadata is fetched from the client's own `client_id` URL instead of registering a new row per connection.
* **Client type:** public clients only — `token_endpoint_auth_methods_supported: ["none"]`. There's no client-secret flow.
* **Scope:** every MCP client is pinned to `mcp:use` regardless of what it requests. A token that carries `mcp:use` is rejected by every `/v1` and `/v2` REST route, and a normal API token is rejected by the MCP endpoint — the two token types don't cross over.
* **Token lifetimes:** access tokens expire after 1 hour; refresh tokens after 30 days and rotate on use — reusing a spent refresh token returns `invalid_grant`.
* **Loopback redirects:** `http://localhost/callback` and `http://127.0.0.1/callback` match on any port, for local tools like Claude Code.
* **Token endpoint:** accepts `application/x-www-form-urlencoded`, per the OAuth spec.
* **Tool results:** every tool except `get_zeeg_guide` returns `structuredContent` described by its `outputSchema` in `tools/list`, plus the same JSON as a text block for clients that read only text.