# Zen Planner API and MCP server

> Yes, but only for partners: Zen Planner has an API on the Daxko Partners portal, and its docs say "Contact your Daxko sales representative to request access" (checked 11 Oct 2026). Studios cannot create a key themselves in Zen Planner Studio.

Management software for gyms, CrossFit boxes, martial arts schools and yoga studios: memberships, online class booking, attendance, billing, leads and belt tracking in one place.

## What is the Zen Planner API?

Cotlet's Zen Planner API exposes 14 endpoints for your own Zen Planner account: list members, get member, list classes, get class roster, list attendance, list prospects, list failed payments, get revenue report, book class, cancel reservation, check in member, create prospect, enroll in membership and promote rank. The list_members endpoint returns people in your studio with status, email, phone and memberships. Each endpoint takes simple JSON inputs like person_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

Yes, but only for partners: Zen Planner has an API on the Daxko Partners portal, and its docs say "Contact your Daxko sales representative to request access" (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Zen Planner with 14 endpoints (8 read, 6 write): your AI agent signs in as you and does the work.

## Does Zen Planner have an official API?

Yes, but only for partners: Zen Planner has an API on the Daxko Partners portal, and its docs say "Contact your Daxko sales representative to request access" (checked 11 Oct 2026). Studios cannot create a key themselves in Zen Planner Studio.

| Task | Zen Planner official | Cotlet |
|---|---|---|
| Look up members and their memberships | Partly: Partner API only, via Daxko sales | Yes |
| Reserve and cancel class spots | Partly: Partner API only, via Daxko sales | Yes |
| Check members into a class | Partly: Partner API only, via Daxko sales | Yes |
| Enroll a member in a membership | Partly: Partner API only, via Daxko sales | Yes |
| Add prospects | Partly: Partner API can create, not list them | Yes |
| List failed payments | No: Shown in Zen Planner reports, not in the API | Yes |
| Revenue reports by membership type, class or instructor | No: Shown in Zen Planner reports, not in the API | Yes |
| Promote a student to a new rank | No | Yes |

Sources: [Daxko Partners API documentation (Zen Planner API)](https://docs.partners.daxko.com/openapi/ZenPlanner/v1/), [Zen Planner integrations](https://www.zenplanner.com/integrations), [Zen Planner reporting and dashboards](https://www.zenplanner.com/features/reporting-dashboards-software), [Zen Planner help: preset automations (failed payment, absent member, new prospect)](https://help.daxko.com/s/article/ZEN-PLANNER-How-Do-I-Set-Up-Automated-Emails), [Zen Planner Engage (add-on marketing automation)](https://www.zenplanner.com/engage)

## For AI agents

```text
Yes, but only for partners: Zen Planner has an API on the Daxko Partners portal, and its docs say "Contact your Daxko sales representative to request access" (checked 11 Oct 2026). Studios cannot create a key themselves in Zen Planner Studio.
Cotlet provides a hosted MCP server and REST API for Zen Planner: 14 tools (8 read, 6 write).
Access       Request access at https://cotlet.dev/app/signup?app=zen-planner; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/zen-planner
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_members, get_member, list_classes, get_class_roster, list_attendance, list_prospects, list_failed_payments, get_revenue_report, book_class, cancel_reservation, check_in_member, create_prospect, enroll_in_membership, promote_rank
Confirm      book_class, cancel_reservation, check_in_member, create_prospect, enroll_in_membership, promote_rank (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/zen-planner-api-mcp-server.md

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

## What can an AI agent do in Zen Planner?

Cotlet is best for gym and studio owners and managers who want their AI agent to chase failed payments, book classes, check in rosters and pull revenue in Zen Planner without running or fixing a server.

- **[Follow up on failed payments](https://cotlet.dev/integrations/zen-planner-api-mcp-server/list-failed-payments)** (runs: weekly): "Every Monday, list last week's failed Zen Planner payments, sorted by what each member has to do to fix them, with phone numbers, and tell me which of those people are still coming to class." → `list_failed_payments`, `get_member`, `list_attendance`
- **Book members into classes**: "Book Sarah Lee into tomorrow's 6:00 class." → `list_members`, `list_classes`, `book_class`
- **[Find members who stopped coming](https://cotlet.dev/integrations/zen-planner-api-mcp-server/find-inactive-members)** (runs: weekly): "Every Friday, find Zen Planner members who used to train at least twice a week but have not checked in for 14 days, and give me a call list for the coaches with their usual class." → `list_members`, `list_attendance`, `get_member`
- **[Import leads as prospects](https://cotlet.dev/integrations/zen-planner-api-mcp-server/add-prospects-from-csv)**: "Add the leads from open-house.csv to Zen Planner as prospects with source Open house. Skip anyone who is already in Zen Planner and show me the list before you add them." → `list_members`, `create_prospect`, `list_prospects`
- **Check in a class roster**: "Check in everyone on the 9:00 kids class roster except Sam and Mia." → `get_class_roster`, `check_in_member`
- **Monthly revenue by membership type** (runs: monthly): "Compare September and August revenue by membership type." → `get_revenue_report`

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

Yes. Cotlet does not replace your automation platform: it gives it a Zen Planner 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 follow up on failed payments, 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/zen-planner/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/zen-planner/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/zen-planner/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/zen-planner/{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 Zen Planner.

### list_members

People in your studio with status, email, phone and memberships. Access: read. REST: `POST /api/v1/zen-planner/list_members`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | no | Name or email to search for. |
| `status` | enum | no | member, prospect, alumni or all. Default: member. |
| `modified_after` | date | no | Only people changed on or after this date. |
| `limit` | integer | no | 1 to 200. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists people in your studio, filtered by name or email, status or last change date. Each item has a person_id, contact details and the names of their active memberships. Pages hold up to 200 people; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "members": [
    {
      "person_id": "p253ac9b9",
      "name": "Sarah Lee",
      "status": "member",
      "email": "sarah.lee@example.com",
      "phone": "+1 555 0142",
      "memberships": [
        "Unlimited Monthly"
      ]
    }
  ],
  "next_cursor": null
}
```

### get_member

Full profile: contact details, memberships and family members. Access: read. REST: `POST /api/v1/zen-planner/get_member`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `person_id` | string | yes | Person ID from list_members. |

Returns one person with contact details, their memberships with start dates and the family members linked to the account. Use it to get a phone number or email before contacting someone.

Example response:

```json
{
  "person_id": "p253ac9b9",
  "name": "Sarah Lee",
  "email": "sarah.lee@example.com",
  "phone": "+1 555 0142",
  "memberships": [
    {
      "membership_id": "ms_3310",
      "type": "Unlimited Monthly",
      "start_date": "2026-03-01"
    }
  ],
  "family": []
}
```

### list_classes

Class schedule with time, instructor, capacity and open spots. Access: read. REST: `POST /api/v1/zen-planner/list_classes`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | First day. |
| `to` | date | no | Last day. Default: same as from. |
| `location_id` | string | no | Only classes at this location. |
| `program_id` | string | no | Only classes of this program. |

Returns the classes in a date range in start order, each with class_id, time, instructor, capacity and open spots. Filter by location or program to narrow the list. Use class_id with book_class and get_class_roster.

Example response:

```json
{
  "classes": [
    {
      "class_id": "c7e2a91f",
      "name": "CrossFit WOD",
      "starts_at": "2026-10-12T06:00:00-04:00",
      "instructor": "Coach Alex",
      "capacity": 12,
      "open_spots": 4
    }
  ]
}
```

### get_class_roster

Who reserved and who checked in for one class. Access: read. REST: `POST /api/v1/zen-planner/get_class_roster`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `class_id` | string | yes | Class ID from list_classes. |

Returns the people who reserved one class, each with a reservation_id and whether they are checked in. Use reservation_id with cancel_reservation and person_id with check_in_member.

Example response:

```json
{
  "class_id": "c4d8b1e0",
  "name": "Kids Karate",
  "starts_at": "2026-10-11T09:00:00-04:00",
  "roster": [
    {
      "reservation_id": "r_5501",
      "person_id": "p253ac9b9",
      "name": "Ava Lee",
      "checked_in": false
    },
    {
      "reservation_id": "r_5502",
      "person_id": "p77a1d03e",
      "name": "Sam Ortiz",
      "checked_in": false
    }
  ]
}
```

### list_attendance

A member's class check-ins in a date range, newest first. Access: read. REST: `POST /api/v1/zen-planner/list_attendance`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `person_id` | string | yes | Person ID from list_members. |
| `from` | date | no | Start date. Default: 30 days ago. |
| `to` | date | no | End date. Default: today. |

Returns the classes one person checked into between two dates, newest first. An empty list means no visits in that range. Run it once per person.

Example response:

```json
{
  "person_id": "p253ac9b9",
  "attendance": [
    {
      "class_id": "c3a90b12",
      "name": "CrossFit WOD",
      "checked_in_at": "2026-10-07T06:02:00-04:00"
    }
  ]
}
```

### list_prospects

Leads with source, status and date added. Access: read. REST: `POST /api/v1/zen-planner/list_prospects`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | string | no | Prospect status as set up in your studio. |
| `source` | string | no | Lead source, e.g. Website or Walk-in. |
| `since` | date | no | Only prospects added on or after this date. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists prospects in your studio, newest first, filtered by status, source or date added. Status values are the ones set up in your studio. Use it to skip leads that already exist before create_prospect.

Example response:

```json
{
  "prospects": [
    {
      "person_id": "p9be2c71a",
      "name": "Dana Ortiz",
      "source": "Open house",
      "status": "New",
      "added_on": "2026-10-09"
    }
  ],
  "next_cursor": null
}
```

### list_failed_payments

Payments that failed, with member, amount, date and reason. Access: read. REST: `POST /api/v1/zen-planner/list_failed_payments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | no | Start date. Default: 7 days ago. |
| `to` | date | no | End date. Default: today. |
| `location_id` | string | no | Only this location. |

Returns the payments Zen Planner marks as failed in a date range, newest first, with member, amount, date and the reason shown in the report. It is not the past-due total, which Zen Planner counts separately. The total is the sum of the listed amounts.

Example response:

```json
{
  "payments": [
    {
      "person_id": "p253ac9b9",
      "name": "Sarah Lee",
      "amount": 129,
      "date": "2026-10-08",
      "reason": "Card declined"
    },
    {
      "person_id": "p41c7f0d2",
      "name": "Marcus Webb",
      "amount": 89,
      "date": "2026-10-06",
      "reason": "Expired card"
    }
  ],
  "total": 218,
  "currency": "USD"
}
```

### get_revenue_report

Revenue for a period, grouped by membership type, class, instructor, location or retail. Access: read. REST: `POST /api/v1/zen-planner/get_revenue_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | Start date. |
| `to` | date | yes | End date. |
| `group_by` | enum | no | membership_type, class, instructor, location or retail. Default: membership_type. |

Returns revenue for one date range as Zen Planner reports it, grouped the way you choose. One call covers one period; compare two months with two calls. The total is the sum of the groups.

Example response:

```json
{
  "from": "2026-09-01",
  "to": "2026-09-30",
  "group_by": "membership_type",
  "groups": [
    {
      "name": "Unlimited Monthly",
      "revenue": 18450
    },
    {
      "name": "3x Week",
      "revenue": 9200
    },
    {
      "name": "Drop-in",
      "revenue": 1350
    }
  ],
  "total": 29000,
  "currency": "USD"
}
```

### book_class

Reserve a spot in a class for a member. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/book_class`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `class_id` | string | yes | Class ID from list_classes. |
| `person_id` | string | yes | Person ID from list_members. |

Reserves one spot in one class for one member and returns a reservation_id. The member is booked as your staff account does it in Zen Planner Studio. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reservation_id": "r_5510",
  "status": "reserved",
  "class": {
    "name": "CrossFit WOD",
    "starts_at": "2026-10-12T06:00:00-04:00",
    "instructor": "Coach Alex"
  },
  "open_spots_left": 3
}
```

### cancel_reservation

Cancel a member's class reservation. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/cancel_reservation`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `class_id` | string | yes | Class ID from list_classes. |
| `reservation_id` | string | yes | Reservation ID from get_class_roster. |

Cancels one reservation, which frees the spot. Get reservation_id from get_class_roster or book_class. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "reservation_id": "r_5510",
  "status": "cancelled"
}
```

### check_in_member

Record that a member attended a class. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/check_in_member`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `class_id` | string | yes | Class ID from list_classes. |
| `person_id` | string | yes | Person ID from list_members. |

Checks one member into one class, which adds a visit to their attendance. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "class_id": "c4d8b1e0",
  "person_id": "p253ac9b9",
  "status": "checked_in",
  "checked_in_at": "2026-10-11T09:04:00-04:00"
}
```

### create_prospect

Add a lead with contact details and source. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/create_prospect`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `first_name` | string | yes | First name. |
| `last_name` | string | yes | Last name. |
| `email` | string | no | Email address. |
| `phone` | string | no | Phone number. |
| `source` | string | no | Lead source, e.g. Open house. |

Adds one prospect and returns its person_id. If your studio has lead follow-up workflows set up in Zen Planner, a new prospect can start them. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "person_id": "p9be2c71a",
  "status": "created",
  "name": "Dana Ortiz",
  "source": "Open house"
}
```

### enroll_in_membership

Add a membership to a member. Billing follows the membership type. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/enroll_in_membership`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `person_id` | string | yes | Person ID from list_members. |
| `membership_type_id` | string | yes | Membership type, e.g. Unlimited Monthly. |
| `start_date` | date | no | Default: today. |

Adds a membership to a member from a given start date. Billing then follows the terms of that membership type in your studio, so this reaches money. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "membership_id": "ms_4402",
  "person_id": "p253ac9b9",
  "type": "Unlimited Monthly",
  "start_date": "2026-10-12",
  "status": "active"
}
```

### promote_rank

Move a student to their next belt or rank. Access: write, asks the user first. REST: `POST /api/v1/zen-planner/promote_rank`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `person_id` | string | yes | Person ID from list_members. |
| `rank` | string | yes | New rank name from your rank structure. |
| `promoted_on` | date | no | Promotion date. Default: today. |

Records a new rank for a student from your own rank structure, as in Zen Planner's belt and skill tracking. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "person_id": "p77a1d03e",
  "rank": "Yellow Belt",
  "promoted_on": "2026-10-11",
  "status": "promoted"
}
```

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

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

### Connect Zen Planner to your agent.

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

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

```
Every Monday, list last week's failed Zen Planner payments, sorted by what each member has to do to fix them, with phone numbers, and tell me which of those people are still coming to class.
```

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

```
curl https://cotlet.dev/api/v1/zen-planner/book_class \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"class_id":"c7e2a91f","person_id":"p253ac9b9"}'
```

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

```
{
  "reservation_id": "r_5510",
  "status": "reserved",
  "class": {
    "name": "CrossFit WOD",
    "starts_at": "2026-10-12T06:00:00-04:00",
    "instructor": "Coach Alex"
  },
  "open_spots_left": 3
}
```

## Why use Cotlet for Zen Planner?

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

## Is there a Zen Planner MCP server on GitHub?

The official route is the Daxko partner API: you ask a Daxko sales rep for credentials, build the integration yourself, and it does not cover failed payments or revenue reports. Cotlet works in your own staff account with no partner agreement, and our team keeps it working.

|  | Daxko partner API | Cotlet |
|---|---|---|
| Access | Credentials only through a Daxko sales rep, under a partner agreement | Request access, then sign in to Zen Planner once in your browser |
| Whose account | A partner integration, set up by developers | Your own staff account, the whole studio |
| Failed payments and revenue | Not in the API; read them in Zen Planner reports | list_failed_payments and get_revenue_report |
| Setup and upkeep | You build, host and maintain the code that calls it | Hosted: one MCP server or API key, nothing to maintain |
| When Zen Planner changes | You update your own code | Our team tests it daily and fixes it for you; failed calls are free |
| Where it runs | Wherever you host your code | Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Set in your Daxko agreement | 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 Zen Planner 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 Zen Planner API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Zen Planner 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 Daxko API credentials?**

No. Cotlet works in your own Zen Planner Studio staff account and does not use the Daxko partner API, whose credentials come only through a Daxko sales rep (checked 11 Oct 2026).

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

No. Every call to book_class, cancel_reservation, check_in_member, create_prospect, enroll_in_membership or promote_rank waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals.

**Can I use the Zen Planner 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/zen-planner/{tool} from the HTTP Request node.