# GlossGenius API and MCP server

> GlossGenius has no public API and no developer docs (checked 11 Oct 2026). Its help center says it offers no direct integrations with third-party accounting or reporting tools; data leaves only as reports and a client list CSV you download by hand.

Booking, payments and client management software for salons, spas, barbers and independent beauty professionals, with an online booking site for clients.

## What is the GlossGenius API?

Cotlet's GlossGenius API exposes 14 endpoints for your own GlossGenius account: list appointments, get appointment, list services, find open slots, find client, get client, list waitlist, get sales summary, book appointment, reschedule appointment, cancel appointment, add client, add client note and block time. The list_appointments endpoint returns appointments in a date range with client, services, provider, deposit and confirmation. Each endpoint takes simple JSON inputs like provider_id, from or to 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:** 14 (8 read, 6 write)
- **Updated:** 2026-10-11

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

## Does GlossGenius have an official API?

GlossGenius has no public API and no developer docs (checked 11 Oct 2026). Its help center says it offers no direct integrations with third-party accounting or reporting tools; data leaves only as reports and a client list CSV you download by hand.

| Task | GlossGenius official | Cotlet |
|---|---|---|
| List upcoming appointments | No: The Appointments report lists past appointments only | Yes |
| Book an appointment for a client | No | Yes |
| Reschedule or cancel an appointment | No | Yes |
| Find a client and read their notes | No | Yes |
| Export the client list | Partly: Manual CSV from the web app, Account Owner only, no notes | Yes |
| Add a client note | No | Yes |
| Read the waitlist | No | Yes |
| Sales totals for a period | Partly: Sales Report as a PDF, pulled by hand | Yes |

Sources: [Is GlossGenius compatible with QuickBooks? (GlossGenius help)](https://glossgenius.elevio.help/en/articles/949-is-glossgenius-compatible-with-reporting-accounting-software-like-quickbooks), [How to export your client list (GlossGenius help)](https://glossgenius.elevio.help/en/articles/792-how-to-export-your-client-list), [Available reports (GlossGenius help)](https://glossgenius.elevio.help/en/articles/117-available-reports), [How to edit or reschedule an appointment (GlossGenius help)](https://glossgenius.elevio.help/en/articles/116-how-to-edit-or-reschedule-an-appointment), [How to manage your waitlist (GlossGenius help)](https://glossgenius.elevio.help/en/articles/647-how-to-manage-your-waitlist), [How to build custom reports with your Growth Analyst (GlossGenius help)](https://glossgenius.elevio.help/en/articles/1191-how-to-build-custom-reports-with-your-growth-analyst), [What is Reception and how it works (GlossGenius help)](https://glossgenius.elevio.help/en/articles/1207-what-is-reception-and-how-it-works)

## For AI agents

```text
GlossGenius has no public API and no developer docs (checked 11 Oct 2026). Its help center says it offers no direct integrations with third-party accounting or reporting tools; data leaves only as reports and a client list CSV you download by hand.
Cotlet provides a hosted MCP server and REST API for GlossGenius: 14 tools (8 read, 6 write).
Access       Request access at https://cotlet.dev/app/signup?app=glossgenius; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/glossgenius
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_appointments, get_appointment, list_services, find_open_slots, find_client, get_client, list_waitlist, get_sales_summary, book_appointment, reschedule_appointment, cancel_appointment, add_client, add_client_note, block_time
Confirm      book_appointment, reschedule_appointment, cancel_appointment, block_time (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/glossgenius-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=glossgenius (GlossGenius is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to GlossGenius 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 GlossGenius 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 GlossGenius 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 GlossGenius's terms; Cotlet is not affiliated with GlossGenius.
```

## What can an AI agent do in GlossGenius?

Cotlet is best for salon, spa and barber owners, and the developers who build for them, who want an AI agent to book, move and note appointments without running or fixing a server.

- **Book client appointments with AI**: "Book Maya for a gel manicure with Sam on Thursday after 3pm, whatever slot is open." → `find_client`, `list_services`, `find_open_slots`, `book_appointment`
- **[Bulk reschedule appointments when you are out sick](https://cotlet.dev/integrations/glossgenius-api-mcp-server/bulk-reschedule-appointments)**: "I'm sick today. Block my calendar, move all my appointments to the next open slots this week or next, and tell me who couldn't be moved." → `block_time`, `list_appointments`, `get_appointment`, `find_open_slots`, `reschedule_appointment`
- **[Fill cancelled slots from the waitlist](https://cotlet.dev/integrations/glossgenius-api-mcp-server/fill-cancelled-slots-from-waitlist)** (runs: daily): "Check tomorrow for open slots and match them against my waitlist. Book whoever fits best and tell me who you booked." → `list_waitlist`, `list_services`, `find_open_slots`, `get_client`, `book_appointment`
- **Save client notes and color formulas**: "Save to Jess's profile: root touch-up, 6N + 20 vol, 35 minutes." → `find_client`, `add_client_note`
- **[Send weekly sales totals to a bookkeeping spreadsheet](https://cotlet.dev/integrations/glossgenius-api-mcp-server/weekly-sales-report-to-spreadsheet)** (runs: weekly): "Every Monday, put last week's GlossGenius sales, tips, taxes, refunds and card fees into my bookkeeping sheet, one row per week." → `get_sales_summary`
- **Sync upcoming appointments to a spreadsheet** (runs: daily): "List next week's appointments and add them to my planning sheet with client, service and time." → `list_appointments`, `get_appointment`

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

Yes. Cotlet does not replace your automation platform: it gives it a GlossGenius 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 fill cancelled slots from the waitlist, 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/glossgenius/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/glossgenius/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/glossgenius/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/glossgenius/{tool} with your API key. | cron or GitHub Actions. |

## Tools

**For AI agents:** Every endpoint and its schema is public. The 14 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 GlossGenius.

### list_appointments

Appointments in a date range with client, services, provider, deposit and confirmation. Access: read. REST: `POST /api/v1/glossgenius/list_appointments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day, inclusive. |
| `to` | date | no | Last day, inclusive. Default: same as from. |
| `provider_id` | string | no | Team member ID from list_services. Default: you. |

Returns the appointments on your GlossGenius calendar in start order, past and future. Cancelled appointments are removed from the calendar, so they are not returned. Another team member's calendar needs the calendar permission for that person.

Example response:

```json
{
  "appointments": [
    {
      "appointment_id": "ap_771920",
      "start": "2026-10-12T11:00:00-04:00",
      "end": "2026-10-12T12:00:00-04:00",
      "client": {
        "client_id": "cl_50377",
        "name": "Jess T."
      },
      "services": [
        "Root Touch-up"
      ],
      "provider": "Sam",
      "deposit_required": false,
      "confirmed": true
    },
    {
      "appointment_id": "ap_771935",
      "start": "2026-10-13T14:00:00-04:00",
      "end": "2026-10-13T14:45:00-04:00",
      "client": {
        "client_id": "cl_48213",
        "name": "Maya R."
      },
      "services": [
        "Gel Manicure"
      ],
      "provider": "Sam",
      "deposit_required": true,
      "confirmed": false
    }
  ]
}
```

### get_appointment

Full appointment: services, duration, address, notes, deposit requirement and confirmation. Access: read. REST: `POST /api/v1/glossgenius/get_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |

Returns one appointment with the fields GlossGenius lets you edit on it: provider, date and time, service duration, services, address, notes, deposit requirement and appointment confirmation. The price shown is the service price; adjustments are made at checkout.

Example response:

```json
{
  "appointment_id": "ap_771935",
  "start": "2026-10-13T14:00:00-04:00",
  "end": "2026-10-13T14:45:00-04:00",
  "client": {
    "client_id": "cl_48213",
    "name": "Maya R."
  },
  "services": [
    {
      "name": "Gel Manicure",
      "duration_minutes": 45,
      "price": 55
    }
  ],
  "provider": "Sam",
  "address": "Studio, 12 Example St",
  "notes": "Prefers short nails.",
  "deposit_required": true,
  "confirmed": false
}
```

### list_services

Your service menu with duration, price, and the team members who offer each service. Access: read. REST: `POST /api/v1/glossgenius/list_services`.

No parameters.

Returns every service on your menu with its ID, duration and price, plus the team members who offer it. Use the IDs in find_open_slots and book_appointment. Team member IDs from here go into every provider_id parameter.

Example response:

```json
{
  "services": [
    {
      "service_id": "sv_1092",
      "name": "Gel Manicure",
      "duration_minutes": 60,
      "price": 55,
      "providers": [
        {
          "provider_id": "tm_207",
          "name": "Sam"
        }
      ]
    },
    {
      "service_id": "sv_1104",
      "name": "Root Touch-up",
      "duration_minutes": 60,
      "price": 85,
      "providers": [
        {
          "provider_id": "tm_207",
          "name": "Sam"
        },
        {
          "provider_id": "tm_311",
          "name": "Ria"
        }
      ]
    }
  ]
}
```

### find_open_slots

Open times for a service on your calendar, after working hours, personal blocks and gap time. Access: read. REST: `POST /api/v1/glossgenius/find_open_slots`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `service_ids` | string[] | yes | One or more service IDs from list_services. |
| `from` | date | yes | First day to search. |
| `to` | date | no | Last day to search. Default: same as from. |
| `provider_id` | string | no | Team member ID from list_services. Default: you. |

Returns start times in your working hours that are free for the combined length of the services, in start order. Appointments, personal time blocks and gap time are taken out. GlossGenius can still book outside these times, so this tool only suggests them.

Example response:

```json
{
  "slots": [
    {
      "start": "2026-10-15T15:30:00-04:00",
      "end": "2026-10-15T16:30:00-04:00",
      "provider_id": "tm_207"
    },
    {
      "start": "2026-10-15T16:30:00-04:00",
      "end": "2026-10-15T17:30:00-04:00",
      "provider_id": "tm_207"
    }
  ]
}
```

### find_client

Search clients by name, email or phone. Access: read. REST: `POST /api/v1/glossgenius/find_client`.

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

Returns matching client profiles with ID, name, email and phone. Client profiles are private to your business. A team member without client permission gets a permission error.

Example response:

```json
{
  "clients": [
    {
      "client_id": "cl_48213",
      "name": "Maya R.",
      "email": "maya@example.com",
      "phone": "+1 555 0100"
    }
  ]
}
```

### get_client

Client profile: contact details, birthday, notes and appointment history. Access: read. REST: `POST /api/v1/glossgenius/get_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |

Returns the client profile with contact details, birthday, saved notes and past and upcoming appointments. Notes include the ones you added under Notes and Forms. Whether the client is banned from online booking is included.

Example response:

```json
{
  "client_id": "cl_50377",
  "name": "Jess T.",
  "email": "jess@example.com",
  "phone": "+1 555 0101",
  "birthday": "1990-03-14",
  "banned_from_online_booking": false,
  "notes": [
    {
      "note_id": "nt_9001",
      "text": "Prefers a cooler tone.",
      "created": "2026-09-02"
    }
  ],
  "appointments": [
    {
      "appointment_id": "ap_771920",
      "start": "2026-10-12T11:00:00-04:00",
      "services": [
        "Root Touch-up"
      ]
    }
  ]
}
```

### list_waitlist

Active waitlist entries with client, service and the time they asked for. Access: read. REST: `POST /api/v1/glossgenius/list_waitlist`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `provider_id` | string | no | Team member ID from list_services. Default: you. |

Returns the active waitlist entries from the Calendar, in the order GlossGenius lists them, each with the client, service, requested time and note. Expired entries are not shown, because GlossGenius does not show them in the app. A client can join the waitlist for any day and time.

Example response:

```json
{
  "entries": [
    {
      "entry_id": "wl_3302",
      "client": {
        "client_id": "cl_48213",
        "name": "Maya R."
      },
      "service": "Gel Manicure",
      "requested_start": "2026-10-16T14:00:00-04:00",
      "requested_end": "2026-10-16T17:00:00-04:00",
      "note": "Any time after 2pm works."
    },
    {
      "entry_id": "wl_3318",
      "client": {
        "client_id": "cl_50377",
        "name": "Jess T."
      },
      "service": "Root Touch-up",
      "requested_start": "2026-10-16T10:00:00-04:00",
      "requested_end": "2026-10-16T12:00:00-04:00",
      "note": ""
    }
  ]
}
```

### get_sales_summary

Sales Report totals: services, retail, gratuity, cash and check, taxes, refunds and card fees. Access: read. REST: `POST /api/v1/glossgenius/get_sales_summary`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day, inclusive. |
| `to` | date | yes | Last day, inclusive. |

Returns the figures of the Sales Report for the period: service and retail sales, gratuity collected, cash and check amounts, taxes paid, refunds given and card transaction fees. It needs the View Reports permission. It returns nothing while the account is paused, cancelled or disabled.

Example response:

```json
{
  "from": "2026-10-05",
  "to": "2026-10-11",
  "services_sales": 4120,
  "retail_sales": 310,
  "total_sales": 4430,
  "gratuity": 655,
  "cash_and_check": 420,
  "taxes": 24.8,
  "refunds": 55,
  "card_fees": 128.45
}
```

### book_appointment

Book a client into a time on your calendar. GlossGenius notifies the client if you ask it to. Access: write, asks the user first. REST: `POST /api/v1/glossgenius/book_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |
| `service_ids` | string[] | yes | Service IDs from list_services. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `provider_id` | string | no | Team member ID from list_services. Default: you. |
| `notes` | string | no | Appointment notes. |
| `notify_client` | boolean | no | Notify the client of the booking. Default: true. |

Creates one appointment and returns its ID, time and services. GlossGenius allows booking any day and time, even outside working hours, so call find_open_slots first. It books one appointment, not a repeating series. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_771904",
  "status": "booked",
  "start": "2026-10-15T15:30:00-04:00",
  "end": "2026-10-15T16:30:00-04:00",
  "services": [
    {
      "name": "Gel Manicure",
      "price": 55
    }
  ],
  "provider": "Sam",
  "deposit_required": false,
  "client_notified": true
}
```

### reschedule_appointment

Move an appointment to a new time or provider. Access: write, asks the user first. REST: `POST /api/v1/glossgenius/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. |
| `provider_id` | string | no | Team member ID from list_services. Default: you. |
| `notify_client` | boolean | no | Notify the client by email and text. Default: true. |

Changes the date, time and optionally the provider of one appointment, and returns the old and new time. It does not change the price; GlossGenius adjusts prices at checkout. Moving to another team member needs calendar access to that person. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_771920",
  "status": "rescheduled",
  "previous_start": "2026-10-12T11:00:00-04:00",
  "start": "2026-10-20T11:00:00-04:00",
  "end": "2026-10-20T12:00:00-04:00",
  "provider": "Sam",
  "client_notified": true
}
```

### cancel_appointment

Cancel one appointment, or this and all future appointments if it repeats. Access: write, asks the user first. REST: `POST /api/v1/glossgenius/cancel_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `scope` | enum | no | this_one or whole_series. Default: this_one. |
| `notify_client` | boolean | no | Notify the client by email and text. Default: true. |

Cancels the appointment and removes it from your calendar, or the whole repeating series with whole_series. With notify_client on, GlossGenius emails and texts the client about the cancellation. Cancelling cannot be undone with Cotlet; book the client again with book_appointment. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_771935",
  "status": "cancelled",
  "scope": "this_one",
  "client_notified": true
}
```

### add_client

Create a client profile. Nothing is sent to the client. Access: write. REST: `POST /api/v1/glossgenius/add_client`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | First and last name. |
| `email` | string | no | Client email. Email or phone is required. |
| `phone` | string | no | Client mobile number that can receive texts. Email or phone is required. |
| `birthday` | date | no | Client birthday. |

Creates a profile and returns its client ID. It reaches no one: GlossGenius sends client notifications only for bookings and changes, to the contact details on the profile, so check that they are right. This call does not ask for your OK; delete the profile in GlossGenius to undo it.

Example response:

```json
{
  "client_id": "cl_50412",
  "name": "Dana K.",
  "email": "dana@example.com",
  "phone": null
}
```

### add_client_note

Save a note or formula to a client profile. Notes are private to your business. Access: write. REST: `POST /api/v1/glossgenius/add_client_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from find_client. |
| `text` | string | yes | Note text. |

Adds a blank note under Notes and Forms on the client profile and returns its ID. It reaches no one, because client profiles are private to your business, so it does not ask for your OK. Delete the note in the client profile to undo it.

Example response:

```json
{
  "note_id": "nt_9014",
  "client_id": "cl_50377",
  "saved": true
}
```

### block_time

Add a personal time block so clients cannot book you then. Access: write, asks the user first. REST: `POST /api/v1/glossgenius/block_time`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `start` | datetime | yes | ISO 8601 with time zone. |
| `end` | datetime | yes | ISO 8601 with time zone. |
| `description` | string | no | For example "Vacation" or "Lunch break". Clients do not see it. |
| `provider_id` | string | no | Team member ID from list_services. Default: you. |

Adds one personal block to the calendar, so clients cannot book you online during it. It does not touch appointments already on the calendar; run list_appointments for the same range first. It adds one block, not a repeating one. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "block_id": "bl_6120",
  "start": "2026-10-16T09:00:00-04:00",
  "end": "2026-10-16T18:00:00-04:00",
  "description": "Day off",
  "provider": "Sam"
}
```

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

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

### Connect GlossGenius to your agent.

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

2. **Sign in to GlossGenius once** Open the connect page from the console and sign in to GlossGenius 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 GlossGenius 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.

```
Book Maya for a gel manicure with Sam on Thursday after 3pm, whatever slot is open.
```

### Call GlossGenius 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/glossgenius/{tool}. Send its parameters as JSON, exactly as listed in the endpoints above.

```
curl https://cotlet.dev/api/v1/glossgenius/book_appointment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id":"cl_48213","service_ids":["sv_1092"],"start":"2026-10-15T15:30:00-04:00","provider_id":"tm_207","notify_client":true}'
```

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

```
{
  "appointment_id": "ap_771904",
  "status": "booked",
  "start": "2026-10-15T15:30:00-04:00",
  "end": "2026-10-15T16:30:00-04:00",
  "services": [
    {
      "name": "Gel Manicure",
      "price": 55
    }
  ],
  "provider": "Sam",
  "deposit_required": false,
  "client_notified": true
}
```

## Why use Cotlet for GlossGenius?

**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 GlossGenius 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 GlossGenius changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is there a GlossGenius MCP server on GitHub?

GlossGenius has no Zapier app, public API or open-source MCP server (checked 11 Oct 2026). Today you open the web app, download reports and the client CSV by hand, and book or move appointments one at a time. Cotlet hosts an MCP server and REST API for your account, and our team keeps it working.

|  | By hand in the app | Cotlet |
|---|---|---|
| Setup | Log in on the web or in the app and open the Calendar, Clients or Reports | Request access, sign in to GlossGenius once, add one MCP server or API key |
| Upcoming appointments | Read them in the Calendar; the Appointments report lists past ones only | Any date range, past or future, as data your agent can use |
| Booking and rescheduling | One appointment at a time, by hand | Your agent books, moves and cancels; each client-facing change is confirmed by you |
| Client notes | Type them in the client profile; the client CSV leaves them out | Your agent reads and adds notes on any client profile |
| Your GlossGenius session | Your own login in your browser | Session only, encrypted in an EU vault; never your password; revoked in one click |
| When the app changes | You relearn the screens | Our team tests it daily and fixes it for you; failed calls are free |
| Price | Free with your GlossGenius plan | 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 GlossGenius 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 GlossGenius API cost?

Free 7-day trial with 5,000 credits, no card needed. After that, the GlossGenius 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 GlossGenius 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 GlossGenius 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 GlossGenius tool you allowed. When it expires, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security)
- **Revoking access:** Disconnect GlossGenius 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.
- **GlossGenius's terms:** You use your own GlossGenius account and stay responsible for following GlossGenius's terms. Cotlet is independent and not affiliated with GlossGenius. [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 GlossGenius. Cotlet reviews each request and emails you your API key.

**Do I need to be technical?**

No. You sign in to GlossGenius 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 GlossGenius session would leave my computer.**

Cotlet keeps your GlossGenius 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.

**Which GlossGenius plan and role do I need?**

Calendar, client and report features are available on all GlossGenius plans. Reports need the View Reports permission, and only the Account Owner can export the client list, so team members need calendar, client and reports permissions for the matching tools.

**Does it replace GlossGenius waitlist alerts?**

No. On Gold and Platinum plans GlossGenius itself emails and texts waitlisted clients when a cancellation opens a matching time. list_waitlist and book_appointment let your agent fill a slot yourself, on any plan.

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

No. Every call to book_appointment, reschedule_appointment, cancel_appointment or block_time 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, add_client_note runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the GlossGenius 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/glossgenius/{tool} from the HTTP Request node.