# Fresha API and MCP server

> Fresha has no public API and no developer docs (checked 11 Oct 2026). Its only official data connection is the paid Data Connector add-on, which syncs your data out to reporting tools through a Snowflake database connection.

Booking, payments and business software for salons, spas, barbers and wellness businesses: a calendar, client list, point of sale, reports and a business wallet, with a marketplace where clients book online.

## What is the Fresha API?

Cotlet's Fresha API exposes 14 endpoints for your own Fresha account: list appointments, find available slots, list clients, get client, list services, list team members, get sales summary, list payouts, create appointment, reschedule appointment, cancel appointment, add client, add client note and add blocked time. The list_appointments endpoint returns appointments in a date range, with client, services, team member and status. Each endpoint takes simple JSON inputs like location_id, team_member_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:** 14 (8 read, 6 write)
- **Updated:** 2026-10-11

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

## Does Fresha have an official API?

Fresha has no public API and no developer docs (checked 11 Oct 2026). Its only official data connection is the paid Data Connector add-on, which syncs your data out to reporting tools through a Snowflake database connection.

| Task | Fresha official | Cotlet |
|---|---|---|
| List appointments | Partly: Data Connector add-on, or an export from the Appointments list | Yes |
| Find free slots and book an appointment | No | Yes |
| Reschedule or cancel an appointment | No | Yes |
| List clients and their last visit | Partly: Data Connector add-on, or a manual Excel or CSV export | Yes |
| Add clients and client notes | No | Yes |
| Sales summary | Partly: Data Connector add-on, or reports exported one at a time | Yes |
| Payouts from your business wallet | No | Yes |
| Block time in the calendar | No | Yes |

Sources: [Fresha Help Center: Data connector tools](https://www.fresha.com/help-center/knowledge-base/reports/479-available-data-connector-tools), [Fresha pricing and add-ons](https://www.fresha.com/pricing), [Fresha Help Center: export reports](https://www.fresha.com/help-center/knowledge-base/reports/191-export-reports), [Fresha Help Center: update appointment statuses](https://www.fresha.com/help-center/knowledge-base/calendar/600-update-appointment-statuses), [Fresha: Connect (Client Connect and AI Concierge add-on)](https://www.fresha.com/for-business/features/connect)

## For AI agents

```text
Fresha has no public API and no developer docs (checked 11 Oct 2026). Its only official data connection is the paid Data Connector add-on, which syncs your data out to reporting tools through a Snowflake database connection.
Cotlet provides a hosted MCP server and REST API for Fresha: 14 tools (8 read, 6 write).
Access       Request access at https://cotlet.dev/app/signup?app=fresha; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/fresha
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_appointments, find_available_slots, list_clients, get_client, list_services, list_team_members, get_sales_summary, list_payouts, create_appointment, reschedule_appointment, cancel_appointment, add_client, add_client_note, add_blocked_time
Confirm      create_appointment, reschedule_appointment, cancel_appointment (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/fresha-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=fresha (Fresha is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to Fresha 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 Fresha server that someone else maintains, including non-developers. Developers who prefer to run and fix code on their own computer can use an open-source Fresha MCP server instead.

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 Fresha 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 Fresha's terms; Cotlet is not affiliated with Fresha.
```

## What can an AI agent do in Fresha?

Cotlet is best for salon and spa owners and their managers who want an AI agent to book, move and cancel Fresha appointments and report on sales without running or fixing a server.

- **[Book appointments from client messages](https://cotlet.dev/integrations/fresha-api-mcp-server/book-appointments-with-ai)**: "Anna Smith just emailed asking for a cut and colour with Sam on Friday afternoon. Find her in Fresha, book the first slot that fits both services and draft my reply." → `list_clients`, `get_client`, `add_client`, `list_services`, `list_team_members`, `find_available_slots`, `create_appointment`
- **[Reschedule or cancel appointments when a team member is out](https://cotlet.dev/integrations/fresha-api-mcp-server/reschedule-appointments-in-bulk)**: "Sam is sick tomorrow. Block his day, move his clients to another stylist at the same time where someone offers the service, and list the ones you could not place before cancelling anything." → `list_team_members`, `list_appointments`, `find_available_slots`, `add_blocked_time`, `reschedule_appointment`, `cancel_appointment`
- **Cancel appointments when someone is out**: "Sam is sick tomorrow. Cancel his appointments with the reason 'Team member unwell' and tell the clients." → `list_appointments`, `cancel_appointment`
- **[Daily sales summary report](https://cotlet.dev/integrations/fresha-api-mcp-server/daily-sales-summary)** (runs: daily): "Every morning at 8, send me yesterday's Fresha sales by payment method for each location, compared with the same weekday last week, and flag refunds over £50." → `get_sales_summary`
- **Find clients who have not come back**: "Which clients have not had an appointment in 90 days and accept marketing? Put them in a CSV." → `list_clients`
- **Reconcile wallet payouts** (runs: weekly): "List my payouts for September with the fees, so I can match them to my bank statement." → `list_payouts`

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

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

### list_appointments

Appointments in a date range, with client, services, team member and status. Access: read. REST: `POST /api/v1/fresha/list_appointments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day. |
| `to` | date | no | Last day. Default: same as from. |
| `status` | string | no | booked, confirmed, completed, cancelled or no_show, or the name of a custom status. Default: all. |
| `team_member_id` | string | no | Only this team member. |
| `client_id` | string | no | Only this client. |
| `location_id` | string | no | Only this location. Default: all locations. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists appointments for the dates you give, ordered by start time. Each one has its client, services, team member and status. Statuses are Booked, Confirmed, Completed, Cancelled and No-show, plus any custom statuses your business created in Settings; custom ones come back under their own name. Pass appointment_id from an item to reschedule_appointment or cancel_appointment. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "appointments": [
    {
      "appointment_id": "ap_90311301",
      "client": {
        "client_id": "cl_48213977",
        "name": "Anna Smith"
      },
      "start_at": "2026-10-15T10:00:00+01:00",
      "end_at": "2026-10-15T10:45:00+01:00",
      "services": [
        "Haircut"
      ],
      "team_member": {
        "team_member_id": "tm_5521",
        "name": "Sam"
      },
      "status": "Booked",
      "location_id": "loc_201"
    }
  ],
  "next_cursor": null
}
```

### find_available_slots

Free start times on one day for one or more services, for anyone or one team member. Access: read. REST: `POST /api/v1/fresha/find_available_slots`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `service_ids` | string[] | yes | Services from list_services, booked in this order. |
| `date` | date | yes | Day to search. |
| `team_member_id` | string | no | Only this team member. Default: anyone. |
| `location_id` | string | no | Only this location. Default: all locations. |

Returns the free start times on one day for the services you list, booked back to back in that order. Each slot names the team member who is free. Pass start_at from a slot to create_appointment or reschedule_appointment. The search covers one day per call.

Example response:

```json
{
  "date": "2026-10-16",
  "slots": [
    {
      "start_at": "2026-10-16T14:30:00+01:00",
      "end_at": "2026-10-16T15:15:00+01:00",
      "team_member_id": "tm_5521",
      "team_member": "Sam"
    },
    {
      "start_at": "2026-10-16T16:00:00+01:00",
      "end_at": "2026-10-16T16:45:00+01:00",
      "team_member_id": "tm_5521",
      "team_member": "Sam"
    }
  ]
}
```

### list_clients

Your client list with contact details, last appointment and marketing consent. Access: read. REST: `POST /api/v1/fresha/list_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Name, email or phone. |
| `last_appointment_before` | date | no | Only clients whose last appointment was before this date. |
| `location_id` | string | no | Only this location. Default: all locations. |
| `limit` | integer | no | 1 to 500. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists clients, A to Z, with contact details, their last appointment date and marketing consent. The last appointment ignores cancelled and no-show bookings, the same as Fresha's Client insights report. Use last_appointment_before to find clients who have not been in since a date. Card details are never returned. Pages hold up to 500 clients; pass next_cursor back as cursor.

Example response:

```json
{
  "clients": [
    {
      "client_id": "cl_48213977",
      "name": "Anna Smith",
      "email": "anna@example.com",
      "phone": "+44 7700 900123",
      "last_appointment": "2026-06-20",
      "accepts_marketing": true,
      "accepts_sms_marketing": false
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjEwMH0"
}
```

### get_client

Client profile: details, notes, allergies, and upcoming and past appointments. Access: read. REST: `POST /api/v1/fresha/get_client`.

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

Returns one client's profile: contact details, the notes your team saved, allergies, and upcoming and past appointments, newest first. Notes are visible only to your team. Use it before booking or writing to a client.

Example response:

```json
{
  "client_id": "cl_48213977",
  "name": "Anna Smith",
  "phone": "+44 7700 900123",
  "notes": [
    {
      "text": "Prefers a warm toner, no fragrance.",
      "created_at": "2026-05-14T11:02:00+01:00"
    }
  ],
  "allergies": [],
  "upcoming_appointments": [
    {
      "appointment_id": "ap_90311245",
      "start_at": "2026-10-16T14:30:00+01:00",
      "services": [
        "Haircut"
      ]
    }
  ],
  "past_appointments": [
    {
      "appointment_id": "ap_88120411",
      "start_at": "2026-06-20T11:00:00+01:00",
      "services": [
        "Colour"
      ],
      "status": "Completed"
    }
  ]
}
```

### list_services

Your service menu with categories, durations and prices. Access: read. REST: `POST /api/v1/fresha/list_services`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `location_id` | string | no | Only this location. Default: all locations. |

Returns your service menu grouped by category, with duration and price for each service. Prices are in your business currency. Use service_id from an item in find_available_slots and create_appointment.

Example response:

```json
{
  "services": [
    {
      "service_id": "sv_1203",
      "name": "Haircut",
      "category": "Hair",
      "duration_minutes": 45,
      "price": "45.00",
      "currency": "GBP"
    },
    {
      "service_id": "sv_1288",
      "name": "Colour",
      "category": "Hair",
      "duration_minutes": 90,
      "price": "85.00",
      "currency": "GBP"
    }
  ]
}
```

### list_team_members

Bookable team members with their locations and services. Access: read. REST: `POST /api/v1/fresha/list_team_members`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `location_id` | string | no | Only this location. Default: all locations. |

Lists the team members who can be booked, with their locations and the services each one offers. Use team_member_id from an item to filter list_appointments or to book with a specific person.

Example response:

```json
{
  "team_members": [
    {
      "team_member_id": "tm_5521",
      "name": "Sam",
      "locations": [
        "loc_201"
      ],
      "service_ids": [
        "sv_1203",
        "sv_1288"
      ]
    }
  ]
}
```

### get_sales_summary

Sales, discounts and refunds from the Sales summary report, for a date range. Access: read. REST: `POST /api/v1/fresha/get_sales_summary`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day. |
| `to` | date | no | Last day. Default: same as from. |
| `group_by` | enum | no | payment_method, discount_name or discount_type. Default: no grouping. |
| `location_id` | string | no | Only this location. Default: all locations. |

Returns the Sales summary report for the dates you give: items sold, sales, discounts and refunds. Set group_by to split the totals by payment method, discount name or discount type. Tips and service charges are not in this report, because it is built from sale items. Amounts are in your business currency.

Example response:

```json
{
  "from": "2026-10-10",
  "to": "2026-10-10",
  "currency": "GBP",
  "groups": [
    {
      "payment_method": "Card",
      "items_sold": 18,
      "sales": "742.00",
      "discounts": "30.00",
      "refunds": "0.00"
    },
    {
      "payment_method": "Cash",
      "items_sold": 7,
      "sales": "266.00",
      "discounts": "10.00",
      "refunds": "45.00"
    }
  ],
  "total": {
    "items_sold": 25,
    "sales": "1008.00",
    "discounts": "40.00",
    "refunds": "45.00"
  }
}
```

### list_payouts

Payouts from your business wallet to your bank, with dates, amounts and fees. Access: read. REST: `POST /api/v1/fresha/list_payouts`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | no | Start of the period. Default: 30 days ago. |
| `to` | date | no | End of the period. Default: today. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists transfers from your business wallet to your bank, newest first. Each has its date, amount, the fees Fresha deducted and the net amount. Scheduled and manual payouts are both included. It works only when Fresha Payments is on, and the account needs the Wallet and card processing permission.

Example response:

```json
{
  "payouts": [
    {
      "payout_id": "po_77120",
      "type": "scheduled",
      "date": "2026-09-29",
      "amount": "840.00",
      "fees": "12.60",
      "net": "827.40",
      "currency": "GBP"
    },
    {
      "payout_id": "po_76988",
      "type": "manual",
      "date": "2026-09-22",
      "amount": "300.00",
      "fees": "0.50",
      "net": "299.50",
      "currency": "GBP"
    }
  ],
  "next_cursor": null
}
```

### create_appointment

Book one or more services for a client at a given time. Access: write, asks the user first. REST: `POST /api/v1/fresha/create_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from list_clients. |
| `start_at` | datetime | yes | ISO 8601 with time zone. |
| `service_ids` | string[] | yes | Services from list_services, in order. |
| `team_member_id` | string | no | Team member. Default: first available. |
| `location_id` | string | no | Only this location. Default: all locations. |
| `note` | string | no | Appointment note for your team. |

Books the services you list for a client, back to back, from start_at. The appointment starts as Booked. Without team_member_id it goes to the first team member who is free. Check the time with find_available_slots first; a time that is taken fails. The booking can reach the client. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_90311245",
  "status": "Booked",
  "start_at": "2026-10-16T14:30:00+01:00",
  "end_at": "2026-10-16T15:15:00+01:00",
  "services": [
    {
      "service_id": "sv_1203",
      "name": "Haircut",
      "price": "45.00",
      "currency": "GBP"
    }
  ],
  "team_member": "Sam"
}
```

### reschedule_appointment

Move an appointment to a new time, and optionally to another team member. Access: write, asks the user first. REST: `POST /api/v1/fresha/reschedule_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `start_at` | datetime | yes | New start, ISO 8601 with time zone. |
| `team_member_id` | string | no | New team member. Default: unchanged. |

Moves one appointment to a new start time, keeping its services. Set team_member_id to hand it to someone else. Check the new time with find_available_slots first. The move can reach the client. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_90311301",
  "status": "Booked",
  "start_at": "2026-10-16T10:00:00+01:00",
  "end_at": "2026-10-16T10:45:00+01:00",
  "team_member": "Sam"
}
```

### cancel_appointment

Cancel a current or future appointment with one of your cancellation reasons. Access: write, asks the user first. REST: `POST /api/v1/fresha/cancel_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `appointment_id` | string | yes | Appointment ID from list_appointments. |
| `reason` | string | yes | Name of one of your cancellation reasons. |
| `notify_client` | boolean | no | Send the client a cancellation message. Default: true. |
| `scope` | enum | no | this_appointment or whole_series, for repeating appointments. Default: this_appointment. |

Cancels one appointment. Fresha only cancels appointments that start in the future, so a past one fails; mark it as a no-show in the app instead. The reason must be one of the cancellation reasons you manage in Fresha. Your payment policy for the appointment applies as it does in the app. For a repeating series, scope picks this appointment or the whole series. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "ap_90311245",
  "status": "Cancelled",
  "reason": "Team member unwell",
  "scope": "this_appointment",
  "client_notified": true
}
```

### add_client

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

| Parameter | Type | Required | Description |
|---|---|---|---|
| `first_name` | string | yes | First name. |
| `last_name` | string | no | Last name. |
| `email` | string | no | Email. |
| `phone` | string | no | Mobile number with country code. |

Creates a client profile and returns its client_id, which you pass to create_appointment. It sends nothing to the client and reaches no one, so it runs without asking first. Search with list_clients first to avoid a duplicate profile.

Example response:

```json
{
  "client_id": "cl_48213990",
  "name": "Maya Patel",
  "phone": "+44 7700 900456"
}
```

### add_client_note

Save a note on a client profile, such as a color formula or preference. Access: write. REST: `POST /api/v1/fresha/add_client_note`.

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

Adds a simple note to a client profile. Notes are private: only your team sees them, never the client. Fresha cannot recover a deleted note, so the agent adds notes and never deletes them. It reaches no one, so it runs without asking first.

Example response:

```json
{
  "client_id": "cl_48213977",
  "note_id": "nt_5521",
  "created_at": "2026-10-11T09:12:00+01:00"
}
```

### add_blocked_time

Block time in a team member's calendar for a break, training or admin. Access: write. REST: `POST /api/v1/fresha/add_blocked_time`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `team_member_id` | string | yes | Team member from list_team_members. |
| `start_at` | datetime | yes | ISO 8601 with time zone. |
| `end_at` | datetime | yes | ISO 8601 with time zone. |
| `title` | string | no | Reason, e.g. one of your blocked time types. |
| `description` | string | no | Note your team sees on the block. |

Blocks a time range in one team member's calendar, so no one can book it. Use title for a reason such as one of your blocked time types, and description for a note your team sees. It reaches no client and is removed in Fresha in one step, so it runs without asking first.

Example response:

```json
{
  "blocked_time_id": "bt_3302",
  "team_member": "Sam",
  "start_at": "2026-10-14T13:00:00+01:00",
  "end_at": "2026-10-14T14:00:00+01:00",
  "title": "Training"
}
```

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

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

### Connect Fresha to your agent.

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

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

```
Anna Smith just emailed asking for a cut and colour with Sam on Friday afternoon. Find her in Fresha, book the first slot that fits both services and draft my reply.
```

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

```
curl https://cotlet.dev/api/v1/fresha/create_appointment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id":"cl_48213977","start_at":"2026-10-16T14:30:00+01:00","service_ids":["sv_1203"],"team_member_id":"tm_5521"}'
```

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

```
{
  "appointment_id": "ap_90311245",
  "status": "Booked",
  "start_at": "2026-10-16T14:30:00+01:00",
  "end_at": "2026-10-16T15:15:00+01:00",
  "services": [
    {
      "service_id": "sv_1203",
      "name": "Haircut",
      "price": "45.00",
      "currency": "GBP"
    }
  ],
  "team_member": "Sam"
}
```

## Why use Cotlet for Fresha?

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

## Is there a Fresha MCP server on GitHub?

Yes, but only for reports. A community MCP server on GitHub reads Fresha Data Connector tables from Snowflake. It needs the paid add-on, is maintained by one person, and you install and fix it yourself. It does not book, move or cancel appointments. Cotlet hosts and maintains a server that does.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Buy the Data Connector add-on, copy Snowflake credentials into a config file, add it to each MCP client | Request access, sign in to Fresha once, add one MCP server or API key |
| What it can do | Read report tables | Read, plus book, reschedule, cancel, add clients and notes, block time |
| When Fresha changes | It breaks until you or the maintainer fix it | Our team tests it daily and fixes it for you; failed calls are free |
| Your access | Snowflake credentials in a file on your computer | Your Fresha session, encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When access expires | Tools fail until you reset the credentials by hand | If Fresha logs you out, your agent gets a link to sign in again |
| Where it runs | Your computer, while it is on | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free server, plus the paid add-on per location | 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 Fresha 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 Fresha API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Fresha 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 Data Connector add-on?**

No. Cotlet works in your own Fresha account and does not use the Data Connector, which Fresha sells as a paid add-on per location and which only sends data out to reporting tools.

**What Fresha permissions does the account need?**

Cotlet acts as the signed-in user, so it sees what that user sees. Exporting reports needs the Access reporting and Access new reporting & insights permissions, exporting clients needs Can download clients, and wallet activity needs Wallet and card processing.

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

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

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