# Setmore API and MCP server

> Setmore has an API, but only on the Pro plan and only after you email api@setmore.com and get approved (checked 11 Oct 2026). Its help center says it supports creating, updating and canceling appointments and reading customer and staff data; the Free plan gets no API.

Online appointment scheduling for small businesses: a Booking Page, a team calendar, customers, services, classes and payments.

## What is the Setmore API?

Cotlet's Setmore API exposes 15 endpoints for your own Setmore account: list appointments, get appointment, list available slots, list services, list staff, find customer, get customer, get appointment report, create appointment, reschedule appointment, cancel appointment, set appointment label, add customer note, block time and delete event. The list_appointments endpoint returns appointments in a date range with customer, service, team member, time and label. Each endpoint takes simple JSON inputs like staff_id, service_id or appointment_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:** 15 (8 read, 7 write)
- **Updated:** 2026-10-11

Setmore has an API, but only on the Pro plan and only after you email api@setmore.com and get approved (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Setmore with 15 endpoints (8 read, 7 write): your AI agent signs in as you and does the work.

## Does Setmore have an official API?

Setmore has an API, but only on the Pro plan and only after you email api@setmore.com and get approved (checked 11 Oct 2026). Its help center says it supports creating, updating and canceling appointments and reading customer and staff data; the Free plan gets no API.

| Task | Setmore official | Cotlet |
|---|---|---|
| List appointments for a day or team member | Partly: Pro plan and approved API access; reading appointments is not named in the help center FAQ | Yes |
| Book an appointment | Partly: Pro plan and approved API access | Yes |
| Reschedule or cancel an appointment | Partly: Pro plan and approved API access | Yes |
| Find a customer and their appointments | Partly: Customer data on Pro and approved access | Yes |
| Label appointments (Confirmed, Done, No-Show) | No | Yes |
| Add customer notes | No | Yes |
| Block time with an event | No | Yes |
| Appointment report by date, service or team member | No | Yes |

Sources: [Request Access to the Setmore API (Setmore Help Center)](https://support.setmore.com/en/articles/579360-request-access-to-the-setmore-api), [Setmore pricing](https://www.setmore.com/pricing), [Zapier (Setmore Help Center)](https://support.setmore.com/en/articles/490968-zapier), [Label appointments to track their status (Setmore Help Center)](https://support.setmore.com/en/articles/491015-label-appointments-to-track-their-status), [Book, Reschedule, or Cancel an Appointment (Setmore Help Center)](https://support.setmore.com/en/articles/490875-book-reschedule-or-cancel-an-appointment), [Export Appointment History (Setmore Help Center)](https://support.setmore.com/en/articles/491014-export-appointment-history)

## For AI agents

```text
Setmore has an API, but only on the Pro plan and only after you email api@setmore.com and get approved (checked 11 Oct 2026). Its help center says it supports creating, updating and canceling appointments and reading customer and staff data; the Free plan gets no API.
Cotlet provides a hosted MCP server and REST API for Setmore: 15 tools (8 read, 7 write).
Access       Request access at https://cotlet.dev/app/signup?app=setmore; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/setmore
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_appointments, get_appointment, list_available_slots, list_services, list_staff, find_customer, get_customer, get_appointment_report, create_appointment, reschedule_appointment, cancel_appointment, set_appointment_label, add_customer_note, block_time, delete_event
Confirm      create_appointment, reschedule_appointment, cancel_appointment, delete_event (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/setmore-api-mcp-server.md

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

## What can an AI agent do in Setmore?

Cotlet is best for Setmore owners and front-desk teams on the Free or Pro plan who want their AI agent to handle schedules, reschedules, no-shows and reports without running or fixing a server.

- **Get a daily schedule summary** (runs: daily): "What's on Anna's calendar tomorrow? List each appointment with the customer and service." → `list_staff`, `list_appointments`
- **[Mark no-shows and note repeat offenders](https://cotlet.dev/integrations/setmore-api-mcp-server/mark-no-shows)** (runs: daily): "Every morning, go through yesterday's Setmore appointments that nobody labeled, ask me which customers didn't come, label those No-Show, add a dated note to each customer and tell me who has missed three times in 90 days." → `list_appointments`, `get_customer`, `set_appointment_label`, `add_customer_note`
- **[Bulk reschedule appointments when a team member is out](https://cotlet.dev/integrations/setmore-api-mcp-server/bulk-reschedule-appointments)**: "Anna is out sick Monday. Block her day in Setmore, then move each of her appointments to another team member at a close time the same day, or to Anna's next free slot. Show me the plan before you move anyone." → `list_staff`, `block_time`, `list_appointments`, `list_available_slots`, `reschedule_appointment`
- **Block lunch or prep time on the calendar**: "Block my calendar from 12:00 to 13:00 every day next week for lunch." → `block_time`, `delete_event`
- **[Monthly bookings report by service and team member](https://cotlet.dev/integrations/setmore-api-mcp-server/bookings-report)** (runs: monthly): "On the 1st of each month, tell me how many bookings each team member had last month per service and class, compared with the month before and the same month last year." → `list_services`, `get_appointment_report`

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

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

## Tools

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

### list_appointments

Appointments in a date range with customer, service, team member, time and label. Access: read. REST: `POST /api/v1/setmore/list_appointments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day, in your account time zone. |
| `to` | date | no | Last day. Default: same as from. |
| `staff_id` | string | no | Only this team member, from list_staff. |
| `service_id` | string | no | Only this service, from list_services. |

Returns appointments between two days, in your account time zone, with the customer, service, team member, start and end and the label if you set one. Filter by team member or service. Use appointment_id from each item in get_appointment, reschedule_appointment and cancel_appointment.

Example response:

```json
{
  "appointments": [
    {
      "appointment_id": "apt_51d7e2b9",
      "service": "Massage, 60 min",
      "staff": "Anna",
      "customer": "Sam Client",
      "start": "2026-10-16T15:00:00-04:00",
      "end": "2026-10-16T16:00:00-04:00",
      "label": "Confirmed"
    },
    {
      "appointment_id": "apt_62e8f3ca",
      "service": "Massage, 60 min",
      "staff": "Anna",
      "customer": "Lee Customer",
      "start": "2026-10-16T17:00:00-04:00",
      "end": "2026-10-16T18:00:00-04:00",
      "label": null
    }
  ]
}
```

### get_appointment

One appointment: customer, service, team member, start and end, label and where it was booked. Access: read. REST: `POST /api/v1/setmore/get_appointment`.

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

Returns one appointment with the customer, service, team member, start and end, and its label. Booked via is the source Setmore assigns when the appointment is created, such as the web app, your website or Instagram. It is read only and cannot be edited.

Example response:

```json
{
  "appointment_id": "apt_51d7e2b9",
  "service": "Massage, 60 min",
  "staff": "Anna",
  "customer": {
    "customer_id": "cus_7c04a1",
    "name": "Sam Client"
  },
  "start": "2026-10-16T15:00:00-04:00",
  "end": "2026-10-16T16:00:00-04:00",
  "label": "Confirmed",
  "booked_via": "Booked from website"
}
```

### list_available_slots

Open times for a service on a day, based on working hours and existing bookings. Access: read. REST: `POST /api/v1/setmore/list_available_slots`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `service_id` | string | yes | Service from list_services. |
| `date` | date | yes | Day to check. |
| `staff_id` | string | no | Only this team member. Default: everyone who offers the service. |

Returns open start times for one service on one day. A team member's open times follow their working hours, not your business hours, and exclude their appointments and events. Pass a start from this list to create_appointment or reschedule_appointment.

Example response:

```json
{
  "service": "Massage, 60 min",
  "date": "2026-10-16",
  "slots": [
    {
      "staff_id": "stf_3a90de",
      "staff": "Anna",
      "start": "2026-10-16T09:00:00-04:00"
    },
    {
      "staff_id": "stf_3a90de",
      "staff": "Anna",
      "start": "2026-10-16T13:00:00-04:00"
    },
    {
      "staff_id": "stf_5b12c7",
      "staff": "Ben",
      "start": "2026-10-16T10:00:00-04:00"
    }
  ]
}
```

### list_services

Services and classes with category, cost, duration and the team members who offer them. Access: read. REST: `POST /api/v1/setmore/list_services`.

No parameters.

Lists the services and classes set up in your account, grouped by the categories you use on your Booking Page. Use service_id from each item in list_available_slots, create_appointment and get_appointment_report.

Example response:

```json
{
  "services": [
    {
      "service_id": "svc_8f21c4",
      "name": "Massage, 60 min",
      "category": "Massage",
      "duration_minutes": 60,
      "cost": 80,
      "staff": [
        "Anna",
        "Ben"
      ]
    },
    {
      "service_id": "svc_a19d03",
      "name": "Consultation, 30 min",
      "category": "Consultations",
      "duration_minutes": 30,
      "cost": 0,
      "staff": [
        "Anna"
      ]
    }
  ]
}
```

### list_staff

Team members with the services they offer and their working hours. Access: read. REST: `POST /api/v1/setmore/list_staff`.

No parameters.

Lists the team members in your account with the services each one offers and their working days and hours. Working hours decide a team member's open times. Use staff_id from each item in the other tools.

Example response:

```json
{
  "staff": [
    {
      "staff_id": "stf_3a90de",
      "name": "Anna",
      "services": [
        "Massage, 60 min",
        "Consultation, 30 min"
      ],
      "working_hours": "Mon-Fri 09:00-17:00"
    },
    {
      "staff_id": "stf_5b12c7",
      "name": "Ben",
      "services": [
        "Massage, 60 min"
      ],
      "working_hours": "Tue-Sat 10:00-18:00"
    }
  ]
}
```

### find_customer

Search customers by name, email or phone. Access: read. REST: `POST /api/v1/setmore/find_customer`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | yes | Name, email or phone number. |
| `limit` | integer | no | 1 to 50. Default: 10. |

Searches your customer list and returns matches with contact details. Use customer_id from each item in get_customer, add_customer_note and create_appointment.

Example response:

```json
{
  "customers": [
    {
      "customer_id": "cus_7c04a1",
      "name": "Sam Client",
      "email": "client@example.com",
      "phone": "+1 555 0100"
    }
  ]
}
```

### get_customer

Customer profile: contact details, your private notes and past and upcoming appointments. Access: read. REST: `POST /api/v1/setmore/get_customer`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `customer_id` | string | yes | Customer ID from find_customer. |

Returns one customer with their contact details, your private notes and their past, present and future appointments, as in the Customers tab. Notes are for your reference and the customer does not see them.

Example response:

```json
{
  "customer_id": "cus_7c04a1",
  "name": "Sam Client",
  "email": "client@example.com",
  "phone": "+1 555 0100",
  "notes": "Prefers afternoon slots.",
  "appointments": [
    {
      "appointment_id": "apt_51d7e2b9",
      "service": "Massage, 60 min",
      "start": "2026-10-16T15:00:00-04:00"
    }
  ]
}
```

### get_appointment_report

Appointment history from Reports, filtered by date range, service, class or team member. Access: read. REST: `POST /api/v1/setmore/get_appointment_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | Start date. Up to 3 months per call for best results. |
| `to` | date | yes | End date. |
| `service_id` | string | no | Only this service or class. |
| `staff_id` | string | no | Only this team member. |

Returns the appointment history that Settings > Booking Page > Reports shows in the web app, with counts per team member for the filter you set. Setmore recommends ranges of no more than 3 months for best results. It reads only; nothing is exported to a file.

Example response:

```json
{
  "from": "2026-09-01",
  "to": "2026-09-30",
  "service": "Massage, 60 min",
  "total_appointments": 42,
  "by_staff": [
    {
      "staff": "Anna",
      "appointments": 25
    },
    {
      "staff": "Ben",
      "appointments": 17
    }
  ]
}
```

### create_appointment

Book a service for a customer. Setmore emails the confirmation unless you turned it off. Access: write, asks the user first. REST: `POST /api/v1/setmore/create_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `service_id` | string | yes | Service from list_services. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `customer_id` | string | no | Existing customer from find_customer. Or pass customer. |
| `customer` | object | no | New customer: name, email, phone. Add an email so the customer gets confirmations. |
| `staff_id` | string | no | Team member from list_staff. Default: first one free. |

Books one service with a team member at a start time, for an existing customer or a new one. Setmore sends a booking confirmation email to the provider and the customer unless you turned it off in Settings > Notifications. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "apt_51d7e2b9",
  "status": "booked",
  "service": "Massage, 60 min",
  "staff": "Anna",
  "start": "2026-10-16T15:00:00-04:00",
  "end": "2026-10-16T16:00:00-04:00",
  "customer_id": "cus_7c04a1",
  "confirmation_email": "sent"
}
```

### reschedule_appointment

Move an appointment to a new time or team member. The customer is emailed unless you turned it off. Access: write, asks the user first. REST: `POST /api/v1/setmore/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 | Assign a different team member. |

Changes the start time, the team member, or both for one appointment. Setmore emails the provider and the customer about the change unless rescheduled-appointment emails are off in Settings > Notifications. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "apt_51d7e2b9",
  "status": "rescheduled",
  "staff": "Anna",
  "start": "2026-10-20T15:00:00-04:00",
  "end": "2026-10-20T16:00:00-04:00",
  "customer_email": "sent"
}
```

### cancel_appointment

Delete an appointment from your calendar. The customer is emailed unless you turned it off. Access: write, asks the user first. REST: `POST /api/v1/setmore/cancel_appointment`.

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

Deletes one appointment from the calendar, as Delete does in the app. Setmore notifies the provider and the customer by email unless canceled-appointment emails are off in Settings > Notifications. It cannot be undone with one call; book again with create_appointment. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "apt_62e8f3ca",
  "status": "canceled",
  "customer_email": "sent"
}
```

### set_appointment_label

Track status with a label such as Confirmed or No-Show. Only you and your team see it. Access: write. REST: `POST /api/v1/setmore/set_appointment_label`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `label` | string | yes | Pending, Confirmed, Done, No-Show, Paid, Running Late or one of your custom labels. |

Sets the label on one appointment, like the Label dropdown in the web app. Customers never see labels, and nothing is sent to anyone. It runs without asking first because one call sets the label back.

Example response:

```json
{
  "appointment_id": "apt_51d7e2b9",
  "label": "No-Show",
  "previous_label": "Confirmed"
}
```

### add_customer_note

Add a private note to a customer profile. The customer does not see it. Access: write. REST: `POST /api/v1/setmore/add_customer_note`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `customer_id` | string | yes | Customer ID from find_customer. |
| `note` | string | yes | Note text. |

Writes to the Notes tab of the customer profile, which is for your reference only. Nothing is sent to anyone, so it runs without asking first. A note the customer can see is an appointment comment, which this tool does not write.

Example response:

```json
{
  "customer_id": "cus_7c04a1",
  "status": "saved",
  "note": "No-show on 16 Oct 2026."
}
```

### block_time

Add an Event to the calendar so customers cannot book that time. Access: write. REST: `POST /api/v1/setmore/block_time`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `start` | datetime | yes | ISO 8601 with time zone. |
| `duration_minutes` | integer | yes | Length of the block, within one day. |
| `staff_id` | string | no | Whose calendar, from list_staff. Default: yours. |
| `notes` | string | no | Shown on the event, for example "Lunch". |

Creates a Setmore Event with no guests. Customers cannot book that time on your Booking Page. Events suit blocks within a day; longer absences are Time Off under Settings > Your team, which this tool does not change. It adds no guests, so nobody is emailed and it runs without asking first; delete_event removes it.

Example response:

```json
{
  "event_id": "evt_3d51a8",
  "status": "created",
  "staff": "Anna",
  "start": "2026-10-19T12:00:00-04:00",
  "end": "2026-10-19T13:00:00-04:00",
  "notes": "Lunch"
}
```

### delete_event

Delete an Event from the calendar and free the time. Access: write, asks the user first. REST: `POST /api/v1/setmore/delete_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from block_time. |

Deletes one Event, as Delete does in the app. If the event has guests, Setmore notifies them of the change. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "evt_3d51a8",
  "status": "deleted"
}
```

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

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

### Connect Setmore to your agent.

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

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

```
What's on Anna's calendar tomorrow? List each appointment with the customer and service.
```

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

```
curl https://cotlet.dev/api/v1/setmore/create_appointment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"service_id":"svc_8f21c4","start":"2026-10-16T15:00:00-04:00","customer":{"name":"Sam Client","email":"client@example.com"},"staff_id":"stf_3a90de"}'
```

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

```
{
  "appointment_id": "apt_51d7e2b9",
  "status": "booked",
  "service": "Massage, 60 min",
  "staff": "Anna",
  "start": "2026-10-16T15:00:00-04:00",
  "end": "2026-10-16T16:00:00-04:00",
  "customer_id": "cus_7c04a1",
  "confirmation_email": "sent"
}
```

## Why use Cotlet for Setmore?

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

## Is there a Setmore MCP server on GitHub?

No Setmore MCP server turned up in our check on 11 Oct 2026. The realistic option is Zapier, which Setmore supports on Free and Pro: it has Appointment Updated and Appointment Deleted triggers and actions to create appointments and contacts, for service appointments only.

|  | Zapier | Cotlet |
|---|---|---|
| Setup | Build one Zap per workflow and connect your Setmore account in Zapier | Request access, sign in to Setmore once in your browser, add one MCP server or API key |
| What it can do | Create appointments and contacts; trigger on updated or deleted appointments | Read, book, reschedule and cancel appointments, label them, add customer notes, block time and pull reports |
| Classes | Service appointments only; class bookings are not included | Reports can filter by class |
| When Setmore changes | Setmore maintains its Zapier app | Our team tests it daily and fixes it for you; failed calls are free |
| Your Setmore session | Connected with your Setmore login in Zapier | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| Where it runs | Fixed Zaps in Zapier, not driven by your agent | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Zapier has a free tier; paid plans for more tasks | 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 Setmore 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 Setmore API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Setmore 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 the Pro plan or API approval?**

No. Cotlet works in your own Setmore account on Free or Pro and needs no email to api@setmore.com. Setmore's own API requires a Pro account and approval by email (checked 11 Oct 2026).

**Will customers get emails when my agent books, moves or cancels?**

Yes, as when you do it by hand: Setmore emails the provider and the customer about booked, rescheduled and canceled appointments unless you turned those emails off in Settings > Notifications. Each of those calls asks for your OK by default.

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

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

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