# Mangomint API and MCP server

> Mangomint has no public API and no developer docs (checked 11 Oct 2026). Its Integrations page lists Shopify, Mailchimp, Webhooks, Docovia and Doxy.me; Webhooks only send event data out (appointments, sales, forms, memberships), so nothing can read your calendar on demand or book, move or cancel an appointment.

Booking, checkout and client management software for salons, spas and med spas, with online booking, memberships, forms, an Intelligent Waitlist and built-in reports.

## What is the Mangomint API?

Cotlet's Mangomint API exposes 13 endpoints for your own Mangomint account: list locations, list services, list appointments, find client, get client timeline, list waitlist, get report, export clients, add client note, book appointment, reschedule appointment, cancel appointment and book from waitlist. The list_locations endpoint returns your business locations with address and time zone. Each endpoint takes simple JSON inputs like location_id, staff_id or client_id and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Local services & SaaS](https://cotlet.dev/integrations/category/local-services-saas)
- **Endpoints:** 13 (8 read, 5 write)
- **Updated:** 2026-10-11

Mangomint has no public API and no developer docs (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Mangomint with 13 endpoints (8 read, 5 write): your AI agent signs in as you and does the work.

## Does Mangomint have an official API?

Mangomint has no public API and no developer docs (checked 11 Oct 2026). Its Integrations page lists Shopify, Mailchimp, Webhooks, Docovia and Doxy.me; Webhooks only send event data out (appointments, sales, forms, memberships), so nothing can read your calendar on demand or book, move or cancel an appointment.

| Task | Mangomint official | Cotlet |
|---|---|---|
| List appointments for a day | No: Webhooks send an event when an appointment is created, updated or deleted, not a calendar read | Yes |
| Book an appointment | No | Yes |
| Reschedule or cancel an appointment | No | Yes |
| Find a client and read their timeline | No | Yes |
| Book an opening from the waitlist | No | Yes |
| Pull a sales or retention report | No: Webhooks send each completed sale, not a report | Yes |
| Export the client list | No | Yes |
| Get notified of new bookings and sales | Partly: Outbound webhooks, set up through chat support | Yes |

Sources: [Mangomint Integrations](https://www.mangomint.com/integrations/), [Mangomint Learning Center: Webhooks Integration](https://www.mangomint.com/learn/webhooks-integration/), [Mangomint Learning Center: List of Available Reports](https://www.mangomint.com/learn/available-reports/), [Mangomint Learning Center: Booking an Appointment from the Waitlist](https://www.mangomint.com/learn/book-from-the-waitlist/), [Mangomint Learning Center: Automated Messages, Waitlist Entries](https://www.mangomint.com/learn/automated-messages-waitlist-entries/)

## For AI agents

```text
Mangomint has no public API and no developer docs (checked 11 Oct 2026). Its Integrations page lists Shopify, Mailchimp, Webhooks, Docovia and Doxy.me; Webhooks only send event data out (appointments, sales, forms, memberships), so nothing can read your calendar on demand or book, move or cancel an appointment.
Cotlet provides a hosted MCP server and REST API for Mangomint: 13 tools (8 read, 5 write).
Access       Request access at https://cotlet.dev/app/signup?app=mangomint; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/mangomint
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_locations, list_services, list_appointments, find_client, get_client_timeline, list_waitlist, get_report, export_clients, add_client_note, book_appointment, reschedule_appointment, cancel_appointment, book_from_waitlist
Confirm      book_appointment, reschedule_appointment, cancel_appointment, book_from_waitlist (by default the user approves each call; the user can switch this off per tool, e.g. for scheduled automations)
Markdown     https://cotlet.dev/integrations/mangomint-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=mangomint (Mangomint is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to Mangomint once in a browser. An agent cannot do this step.
3. The API key goes into the MCP client or the REST call as a bearer token.

Fits: people who want a hosted Mangomint server that someone else maintains, including non-developers.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Session: the user signs in to Mangomint in a browser; Cotlet keeps only the session, AES-256 encrypted, revocable in the dashboard at any time.
Terms: the user stays responsible for following Mangomint's terms; Cotlet is not affiliated with Mangomint.
```

## What can an AI agent do in Mangomint?

Cotlet is best for salon and spa owners and front-desk managers who want an AI agent to book, move and report on Mangomint appointments without running or fixing a server.

- **[Reschedule appointments when staff is out](https://cotlet.dev/integrations/mangomint-api-mcp-server/reschedule-appointments-when-staff-is-out)** (runs: daily): "Alex is out sick today. Move her appointments to tomorrow at the same times, or to another stylist who does the same service today, and tell me which ones didn't fit." → `list_appointments`, `list_services`, `reschedule_appointment`
- **[Book a client from the waitlist](https://cotlet.dev/integrations/mangomint-api-mcp-server/book-clients-from-the-waitlist)** (runs: daily): "Check this week's waitlist, show me which entries have an opening, and book each one with the client's requested stylist once I confirm." → `list_waitlist`, `get_client_timeline`, `list_appointments`, `book_from_waitlist`
- **[Weekly sales and cancellations report](https://cotlet.dev/integrations/mangomint-api-mcp-server/weekly-sales-report)** (runs: weekly): "Every Monday, send me last week's Sales Summary next to the week before, sales by staff, and the late cancellations and no-shows with no next appointment." → `list_locations`, `get_report`
- **[Book an appointment from a text or DM](https://cotlet.dev/integrations/mangomint-api-mcp-server/book-appointments-with-ai)**: "Jamie texted asking for a signature facial with Alex next Friday afternoon. Find her, check Alex's day and book the first free slot after 1pm." → `find_client`, `list_services`, `list_appointments`, `book_appointment`
- **Find clients who have not come back** (runs: weekly): "Export clients whose last visit was more than 90 days ago and who have no future appointment." → `export_clients`

## Can Mangomint automations run on a schedule in n8n, Make or Zapier?

Yes. Cotlet does not replace your automation platform: it gives it a Mangomint connection it does not have, with the same API key as your agent. Write actions ask for your OK by default; switch that off in your dashboard for the tools you choose, for example to reschedule appointments when staff is out, and the schedule runs on its own. Cotlet runs in the cloud, so it keeps going while your computer is off.

| Where | How to connect | How to schedule |
|---|---|---|
| Your AI agent | Add https://cotlet.dev/mcp/v1 with your API key. | A scheduled agent run, for example a Claude Code routine. |
| n8n | MCP Client node with https://cotlet.dev/mcp/v1, or an HTTP Request node to https://cotlet.dev/api/v1/mangomint/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/mangomint/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/mangomint/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/mangomint/{tool} with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 13 endpoints on this page, with parameters and example responses, can be listed without an account. Calling one returns 403 until the account has an API key with access to Mangomint.

### list_locations

Your business locations with address and time zone. Access: read. REST: `POST /api/v1/mangomint/list_locations`.

No parameters.

Returns every location in your Mangomint account. Use the location_id from each item in the other tools. Most single-location businesses have one item.

Example response:

```json
{
  "locations": [
    {
      "location_id": "loc_1",
      "name": "Downtown",
      "address": "412 Alder St, Portland, OR",
      "time_zone": "America/Los_Angeles"
    }
  ]
}
```

### list_services

Service menu of a location with duration, price and the staff who perform each service. Access: read. REST: `POST /api/v1/mangomint/list_services`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `location_id` | string | no | Location ID from list_locations. Default: your main location. |

Returns the services you can book at a location, grouped by category, with duration, price and the staff members who perform each one. Use the service_id values in book_appointment.

Example response:

```json
{
  "services": [
    {
      "service_id": "svc_signature_facial",
      "name": "Signature Facial",
      "category": "Facials",
      "duration_minutes": 60,
      "price": {
        "amount": 120,
        "currency": "USD"
      },
      "staff": [
        {
          "staff_id": "st_207",
          "name": "Alex"
        }
      ]
    },
    {
      "service_id": "svc_brow_shape",
      "name": "Brow Shaping",
      "category": "Brows",
      "duration_minutes": 30,
      "price": {
        "amount": 45,
        "currency": "USD"
      },
      "staff": [
        {
          "staff_id": "st_207",
          "name": "Alex"
        },
        {
          "staff_id": "st_311",
          "name": "Sam"
        }
      ]
    }
  ]
}
```

### list_appointments

Appointments on the calendar in a date range with client, services, staff member and notes. Access: read. REST: `POST /api/v1/mangomint/list_appointments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `location_id` | string | no | Location ID from list_locations. Default: your main location. |
| `from` | date | yes | First day, inclusive. |
| `to` | date | no | Last day, inclusive. Default: same as from. |
| `staff_id` | string | no | Only this staff member. |
| `include_canceled` | boolean | no | Also return canceled and no-show appointments. Default: false. |

Returns appointments in a date range in start order, each with client, services, staff member, start, end and appointment note. Filter by staff member to read one calendar. Canceled appointments are left out unless include_canceled is true.

Example response:

```json
{
  "appointments": [
    {
      "appointment_id": "ap_903114",
      "client": {
        "client_id": "cl_48213",
        "name": "Jamie Doe"
      },
      "services": [
        {
          "service_id": "svc_signature_facial",
          "name": "Signature Facial"
        }
      ],
      "staff": {
        "staff_id": "st_207",
        "name": "Alex"
      },
      "start": "2026-10-12T14:00:00-07:00",
      "end": "2026-10-12T15:00:00-07:00",
      "status": "booked",
      "note": null
    }
  ]
}
```

### find_client

Search clients by name, email or phone; returns contact details, tags and client notes. Access: read. REST: `POST /api/v1/mangomint/find_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Name, email or phone number. |

Searches your client list and returns every match with contact details, tags and client notes. Client notes are the internal notes Mangomint shows when you book or check out that client. Pass client_id to the other client tools.

Example response:

```json
{
  "clients": [
    {
      "client_id": "cl_48213",
      "name": "Jamie Doe",
      "email": "client@example.com",
      "phone": "+15035550142",
      "tags": [
        "VIP"
      ],
      "client_notes": [
        "Prefers fragrance-free products"
      ]
    }
  ]
}
```

### get_client_timeline

A client's timeline: past and upcoming appointments, sales, timeline notes and form submissions. Access: read. REST: `POST /api/v1/mangomint/get_client_timeline`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |
| `limit` | integer | no | 1 to 100 entries, newest first. Default: 25. |

Returns entries from one client's timeline, newest first: appointments, sales, timeline notes and submitted forms. Use limit to read the latest few visits before a booking.

Example response:

```json
{
  "client_id": "cl_48213",
  "entries": [
    {
      "type": "appointment",
      "date": "2026-09-14T14:00:00-07:00",
      "summary": "Signature Facial with Alex"
    },
    {
      "type": "sale",
      "date": "2026-09-14T15:05:00-07:00",
      "summary": "Checkout, 1 service, 1 product"
    },
    {
      "type": "timeline_note",
      "date": "2026-09-14T15:10:00-07:00",
      "summary": "Skin was dry; added hydrating serum"
    }
  ]
}
```

### list_waitlist

Intelligent Waitlist entries for a day, with the openings Mangomint found for each. Access: read. REST: `POST /api/v1/mangomint/list_waitlist`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `location_id` | string | no | Location ID from list_locations. Default: your main location. |
| `date` | date | yes | Calendar day to read. |

Returns the waitlist entries for one day with the openings Mangomint found for each. Needs the Intelligent Waitlist app enabled and an Admin user or the Can manage waitlist permission. Pass entry_id and opening_id to book_from_waitlist.

Example response:

```json
{
  "entries": [
    {
      "entry_id": "wl_2207",
      "client": {
        "client_id": "cl_51007",
        "name": "Priya Shah"
      },
      "service": "Signature Facial",
      "openings": [
        {
          "opening_id": "op_88a1",
          "staff": "Alex",
          "start": "2026-10-13T11:00:00-07:00"
        }
      ]
    }
  ]
}
```

### get_report

One of the built-in reports for a date range, as rows. Access: read. REST: `POST /api/v1/mangomint/get_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `report` | enum | yes | sales_summary, service_sales, product_sales, sales_by_time_period, sales_by_staff, canceled_appointments or client_retention. |
| `from` | date | yes | First day, inclusive. |
| `to` | date | yes | Last day, inclusive. |
| `location_ids` | string[] | no | Locations to include. Default: all. |

Returns one of the reports from the Reports app as rows. Sales Summary gives service and product quantities and sales totals for each day; Client Retention gives how many clients from the period visited again within 90 or 180 days. Needs an Admin user or the Can access company reports permission.

Example response:

```json
{
  "report": "sales_summary",
  "from": "2026-10-05",
  "to": "2026-10-11",
  "currency": "USD",
  "rows": [
    {
      "date": "2026-10-05",
      "services_qty": 31,
      "services_total": 3120,
      "products_qty": 6,
      "products_total": 214,
      "total": 3334
    },
    {
      "date": "2026-10-06",
      "services_qty": 28,
      "services_total": 2870,
      "products_qty": 4,
      "products_total": 148,
      "total": 3018
    },
    {
      "date": "2026-10-07",
      "services_qty": 35,
      "services_total": 3540,
      "products_qty": 9,
      "products_total": 302,
      "total": 3842
    },
    {
      "date": "2026-10-08",
      "services_qty": 33,
      "services_total": 3315,
      "products_qty": 5,
      "products_total": 176,
      "total": 3491
    },
    {
      "date": "2026-10-09",
      "services_qty": 41,
      "services_total": 4210,
      "products_qty": 12,
      "products_total": 388,
      "total": 4598
    },
    {
      "date": "2026-10-10",
      "services_qty": 47,
      "services_total": 4760,
      "products_qty": 10,
      "products_total": 341,
      "total": 5101
    },
    {
      "date": "2026-10-11",
      "services_qty": 12,
      "services_total": 1180,
      "products_qty": 2,
      "products_total": 64,
      "total": 1244
    }
  ],
  "totals": {
    "services_qty": 227,
    "services_total": 22995,
    "products_qty": 48,
    "products_total": 1633,
    "total": 24628
  }
}
```

### export_clients

The client list as a CSV download link, with the same filters as the Clients app. Access: read. REST: `POST /api/v1/mangomint/export_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `last_visit_days_ago` | integer | no | Only clients whose last appointment was more than this many days ago. |
| `has_future_appointment` | boolean | no | Only clients with (true) or without (false) a future appointment. |
| `tag` | string | no | Only clients with this tag. |

Applies the filters you give, as the Clients app does, and returns a link to the CSV file. Combine last_visit_days_ago and has_future_appointment to find clients who have not come back. The file has contact details, so open the link yourself.

Example response:

```json
{
  "status": "ready",
  "filters": {
    "last_visit_days_ago": 90,
    "has_future_appointment": false
  },
  "row_count": 42,
  "download_url": "https://files.cotlet.example/exports/mangomint-clients-2026-10-11.csv",
  "expires_at": "2026-10-11T22:00:00+02:00"
}
```

### add_client_note

Add an internal note to a client: a client note shown at booking and checkout, or a dated timeline note. Access: write. REST: `POST /api/v1/mangomint/add_client_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |
| `text` | string | yes | Note text. Internal, never shown to the client. |
| `kind` | enum | no | client or timeline. Default: timeline. |

Adds an internal note to a client profile. A client note shows whenever staff book, view or check out that client; a timeline note is a dated entry on the client timeline. Notes are never shown to the client and reach no one, so add_client_note runs without asking first.

Example response:

```json
{
  "client_id": "cl_48213",
  "kind": "client",
  "status": "added",
  "text": "Allergic to lavender oil"
}
```

### book_appointment

Book one or more services for a client with a staff member. Access: write, asks the user first. REST: `POST /api/v1/mangomint/book_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |
| `location_id` | string | no | Location ID from list_locations. Default: your main location. |
| `service_ids` | string[] | yes | Service IDs from list_services, in order. |
| `staff_id` | string | yes | Staff member performing the services. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `note` | string | no | Appointment note. |

Books the services in the order given, back to back, for one client with one staff member at the start time. The staff member must be on the schedule and free for the full length. Returns the appointment with start and end. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_903114",
  "status": "booked",
  "client": {
    "client_id": "cl_48213",
    "name": "Jamie Doe"
  },
  "services": [
    {
      "service_id": "svc_signature_facial",
      "name": "Signature Facial",
      "duration_minutes": 60
    }
  ],
  "staff": {
    "staff_id": "st_207",
    "name": "Alex"
  },
  "start": "2026-10-16T14:00:00-07:00",
  "end": "2026-10-16T15:00:00-07:00"
}
```

### reschedule_appointment

Move an appointment to a new time, day or staff member. Access: write, asks the user first. REST: `POST /api/v1/mangomint/reschedule_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `start` | datetime | yes | New start, ISO 8601 with time zone. |
| `staff_id` | string | no | New staff member. Default: unchanged. |
| `notify_client` | boolean | no | Send the client a notification about the change. Default: false. |

Moves one appointment to a new start and, if you pass staff_id, to another staff member, as dragging it on the calendar does. Mangomint sends its automated reschedule message only for changes clients make in the client portal, so set notify_client to true to tell the client about this one. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_903114",
  "status": "rescheduled",
  "staff": {
    "staff_id": "st_207",
    "name": "Alex"
  },
  "start": "2026-10-13T11:00:00-07:00",
  "end": "2026-10-13T12:00:00-07:00",
  "client_notified": true
}
```

### cancel_appointment

Cancel an appointment as a normal cancellation, late cancellation or no show. Access: write, asks the user first. REST: `POST /api/v1/mangomint/cancel_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `type` | enum | yes | normal, late or no_show. |

Cancels one appointment with the cancellation type you choose: normal (the client canceled within the cancellation period), late (after it) or no_show. The client is notified if cancellation notifications are on in Mangomint. A late cancellation or no show does not charge a fee by itself; the fee is added at checkout. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_903210",
  "status": "canceled",
  "type": "late"
}
```

### book_from_waitlist

Accept an opening Mangomint found for a waitlist entry and book it. Access: write, asks the user first. REST: `POST /api/v1/mangomint/book_from_waitlist`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `entry_id` | string | yes | Waitlist entry ID from list_waitlist. |
| `opening_id` | string | yes | Opening ID from the same entry. |

Accepts one opening for one waitlist entry, the same as Book on the calendar notification, and puts the client on the calendar. Needs an Admin user or the Can manage waitlist permission. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "entry_id": "wl_2207",
  "status": "booked",
  "appointment_id": "ap_903377",
  "client": {
    "client_id": "cl_51007",
    "name": "Priya Shah"
  },
  "staff": {
    "staff_id": "st_207",
    "name": "Alex"
  },
  "start": "2026-10-13T11:00:00-07:00"
}
```

## How do I connect Mangomint to Claude Code, Codex or Cursor?

Connecting Mangomint takes three steps: request access, sign in to Mangomint once, then add one MCP server or call the REST API with the same key.

### Connect Mangomint to your agent.

1. **Create an account** Sign up and add Mangomint in the console. Your API key is there too.

2. **Sign in to Mangomint once** Open the connect page from the console and sign in to Mangomint the way you always do. We keep the session, never your password, and you can revoke it anytime.

3. **Add Cotlet to your agent** Paste the snippet for your client. The same server and key serve every app you connect, so you do this once.

   Claude Code:

```
claude mcp add --transport http cotlet \
  https://cotlet.dev/mcp/v1 \
  --header "Authorization: Bearer $COTLET_API_KEY"
```

   Cursor:

```
{
  "mcpServers": {
    "cotlet": {
      "url": "https://cotlet.dev/mcp/v1",
      "headers": {
        "Authorization": "Bearer ${COTLET_API_KEY}"
      }
    }
  }
}
```

   Codex:

```
# ~/.codex/config.toml
[mcp_servers.cotlet]
url = "https://cotlet.dev/mcp/v1"
bearer_token_env_var = "COTLET_API_KEY"
```

4. **Ask your agent** Ask in plain words. Your agent finds the Mangomint tools on the server and calls them for you; anything that reaches other people waits for your OK unless you switch that off for a tool.

```
Alex is out sick today. Move her appointments to tomorrow at the same times, or to another stylist who does the same service today, and tell me which ones didn't fit.
```

### Call Mangomint from your scripts.

1. **Export your API key** Your scripts use the same API key as your agent. Keep it in an environment variable, never in your code.

```
export COTLET_API_KEY="cotlet_..."
```

2. **Call a tool** Every tool is a POST endpoint at /api/v1/mangomint/{tool}. Send its parameters as JSON, exactly as listed in the endpoints above.

```
curl https://cotlet.dev/api/v1/mangomint/book_appointment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id":"cl_48213","location_id":"loc_1","service_ids":["svc_signature_facial"],"staff_id":"st_207","start":"2026-10-16T14:00:00-07:00"}'
```

3. **Read the result** You get plain JSON back, ready for your script. A failed call costs nothing.

```
{
  "appointment_id": "ap_903114",
  "status": "booked",
  "client": {
    "client_id": "cl_48213",
    "name": "Jamie Doe"
  },
  "services": [
    {
      "service_id": "svc_signature_facial",
      "name": "Signature Facial",
      "duration_minutes": 60
    }
  ],
  "staff": {
    "staff_id": "st_207",
    "name": "Alex"
  },
  "start": "2026-10-16T14:00:00-07:00",
  "end": "2026-10-16T15:00:00-07:00"
}
```

## Why use Cotlet for Mangomint?

**Built for agents**

- One MCP server for every app you connect.
- The same tools as a REST API for scripts and cron jobs.
- Works with Claude Code, Codex and Cursor.

**Your login stays yours**

- You sign in to Mangomint yourself. We keep only the session, encrypted with AES-256.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Pick read only, or read and write.
- Anything that reaches other people waits for your OK, unless you switch it off per tool.
- Revoke access in one click.

**Kept working for you**

- We test every integration daily.
- When Mangomint changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is there a Mangomint MCP server on GitHub?

No open-source Mangomint MCP server exists. The closest option is Mangomint Webhooks, which send events out to a tool such as Zapier or n8n but cannot read or change anything in Mangomint. Cotlet reads your calendar, clients and reports on demand and can book, move and cancel appointments for you.

|  | Mangomint webhooks | Cotlet |
|---|---|---|
| Setup | Build a receiving endpoint in your workflow tool, then ask Mangomint chat support to set up the webhook | Request access, sign in to Mangomint once, add one MCP server or API key |
| Reading your data | Only events as they happen: appointments, sales, forms, memberships. No lookup of past data | Calendar, clients, waitlist and reports on demand |
| Write actions | None: webhooks cannot book, move or cancel | Book, reschedule and cancel; each one asks for your OK by default |
| When Mangomint changes | Events keep arriving; anything you built on top stays yours to fix | Our team tests it daily and fixes it for you; failed calls are free |
| Your Mangomint session | Not used: events go to your endpoint | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When the session expires | Not applicable: webhooks keep sending | We keep it alive; if Mangomint logs you out, your agent gets a link to sign in again |
| Price | Set by Mangomint and your workflow tool | Free 7-day trial with 5,000 credits, then credits per call |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Mangomint changes, without checking it yourself
- your agent or a script should run it on a schedule, also while your computer is off

**Pick an open-source server if**

- you are comfortable installing, updating and fixing it yourself
- you want the session to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Mangomint API cost?

Free 7-day trial with 5,000 credits, no card needed. After that, the Mangomint API comes with the Cotlet plan, from $29 a month for 3,000 credits, with no limit on apps. Each month's credits stay valid for 3 months, so unused credits add up.

| Size | Price | Credits / month | Per credit |
|---|---|---|---|
| Solo | $29/mo | 3,000 | about $0.0097 |
| Pro | $99/mo | 12,000 | about $0.0083 |
| Agency | $299/mo | 40,000 | $0.0075 |

Each successful call uses credits for the work it takes; failed calls and timeouts cost nothing. A hard spend cap is on by default. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Mangomint account.

- **Company details:** The legal name, address and registration numbers of the company behind Cotlet are in the Terms of service. [Terms](https://cotlet.dev/terms)
- **Your session:** You sign in to Mangomint yourself, in your browser. We keep only the session, never your password: encrypted with AES-256 in an EU vault, isolated to your account and used only when your agent calls a Mangomint tool you allowed. When it expires, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security)
- **Revoking access:** Disconnect Mangomint in your dashboard: the session is deleted and access ends at once. Actions that reach other people wait for your OK unless you switch that off per tool.
- **What we never do:** Store passwords, solve CAPTCHAs or bypass MFA.
- **Mangomint's terms:** You use your own Mangomint account and stay responsible for following Mangomint's terms. Cotlet is independent and not affiliated with Mangomint. [Terms](https://cotlet.dev/terms)
- **Contact:** Questions about the company, security or an app: [contact@cotlet.dev](mailto:contact@cotlet.dev)

## Frequently asked questions

**How do I get access?**

Request access and pick Mangomint. Cotlet reviews each request and emails you your API key.

**Do I need to be technical?**

No. You sign in to Mangomint once in your browser and paste one command into your agent, or one URL into n8n. Your agent can walk you through it. There is no server to install, update or fix.

**Is a hosted server safe? My Mangomint session would leave my computer.**

Cotlet keeps your Mangomint session encrypted with AES-256 in an EU vault, isolated to your account and used only for the tools you allow: read only, or read and write. The AI model never sees it, and you revoke it in one click. A local server keeps the same session in a file on your computer, readable by any program you run, and needs a fresh sign-in whenever it expires.

**Do I need a special Mangomint plan or permission?**

No special plan: Cotlet works in your own Mangomint account. Some tasks need a permission in Mangomint: reports need an Admin user or Can access company reports, and the waitlist needs an Admin user or Can manage waitlist.

**Can my agent post or send messages in Mangomint without asking me?**

No. Every call to book_appointment, reschedule_appointment, cancel_appointment or book_from_waitlist waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. add_client_note runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Mangomint API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call https://cotlet.dev/api/v1/mangomint/{tool} from the HTTP Request node.