# Trainerize API and MCP server

> Trainerize has an API, but only on Studio and Enterprise plans or with the paid FitMetrics add-on (checked 10 Oct 2026). Grow and Pro trainers get Zapier, not the API, and there is no public API reference.

ABC Trainerize is coaching software for personal trainers and studios: client programs, nutrition, habits, check-ins, messaging and appointments in a branded client app.

## What is the Trainerize API?

Cotlet's Trainerize API exposes 14 endpoints for your own Trainerize account: list clients, get client, get body stats, list check-ins, list conversations, get conversation, list master programs, list appointments, send message, subscribe to program, log body stats, schedule appointment, add client tags and set client status. The list_clients endpoint returns clients with client type, trainer, tags and last activity. Each endpoint takes simple JSON inputs like client_id, limit or search and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Courses & training](https://cotlet.dev/integrations/category/courses-training)
- **Endpoints:** 14 (8 read, 6 write)
- **Updated:** 2026-10-10

Trainerize has an API, but only on Studio and Enterprise plans or with the paid FitMetrics add-on (checked 10 Oct 2026). Cotlet is a hosted MCP server and REST API for Trainerize with 14 endpoints (8 read, 6 write): your AI agent signs in as you and does the work.

## Does Trainerize have an official API?

Trainerize has an API, but only on Studio and Enterprise plans or with the paid FitMetrics add-on (checked 10 Oct 2026). Grow and Pro trainers get Zapier, not the API, and there is no public API reference.

| Task | Trainerize official | Cotlet |
|---|---|---|
| List and filter clients | Partly: Studio or Enterprise; Zapier only finds a client by email | Yes |
| Read client progress and body stats | Partly: Studio or Enterprise, last 180 days only | Yes |
| Read check-in forms | Partly: Studio or Enterprise only | Yes |
| Read and send client messages | Partly: Studio or Enterprise; Zapier can send, not read | Yes |
| Subscribe a client to a master program | Partly: Studio or Enterprise, or Zapier on paid plans | Yes |
| Schedule appointments | Partly: Studio or Enterprise only, not in Zapier | Yes |
| Log body stats for a client | Partly: Studio or Enterprise only, not in Zapier | Yes |
| Tag, deactivate or reactivate clients | Partly: Studio or Enterprise, or Zapier on paid plans | Yes |

Sources: [Using API and Webhooks With ABC Trainerize (help center)](https://help.trainerize.com/hc/en-us/articles/37082084919060-Using-API-and-Webhooks-With-ABC-Trainerize), [What Is FitMetrics in ABC Trainerize? (help center)](https://help.trainerize.com/hc/en-us/articles/53910982146708-What-Is-FitMetrics-in-ABC-Trainerize), [Trainerize pricing](https://www.trainerize.com/pricing/), [Trainerize triggers and actions on Zapier](https://zapier.com/apps/abc-trainerize/integrations), [Zapier MCP for ABC Trainerize](https://zapier.com/mcp/abc-trainerize), [Automating Content Delivery with Product Automation (help center)](https://help.trainerize.com/hc/en-us/articles/39988722481044-Automating-Content-Delivery-with-Product-Automation)

## For AI agents

```text
Trainerize has an API, but only on Studio and Enterprise plans or with the paid FitMetrics add-on (checked 10 Oct 2026). Grow and Pro trainers get Zapier, not the API, and there is no public API reference.
Cotlet provides a hosted MCP server and REST API for Trainerize: 14 tools (8 read, 6 write).
Access       Request access at https://cotlet.dev/app/signup?app=trainerize; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/trainerize
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_clients, get_client, get_body_stats, list_check_ins, list_conversations, get_conversation, list_master_programs, list_appointments, send_message, subscribe_to_program, log_body_stats, schedule_appointment, add_client_tags, set_client_status
Confirm      send_message, subscribe_to_program, log_body_stats, schedule_appointment, add_client_tags, set_client_status (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/trainerize-api-mcp-server.md

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

## What can an AI agent do in Trainerize?

Cotlet is best for personal trainers and studio owners on Trainerize Grow or Pro who want their AI agent to handle check-ins, messages, programs and bookings without running or fixing a server.

- **[Follow up with clients who stopped logging body stats](https://cotlet.dev/integrations/trainerize-api-mcp-server/remind-clients-to-log-body-stats)** (runs: weekly): "Find my full-access clients whose last body stats entry is more than two weeks old and draft a short check-in message for each. Leave out anyone who told me they are sick or traveling." → `list_clients`, `get_body_stats`, `list_conversations`, `send_message`
- **[Summarize weekly check-in forms](https://cotlet.dev/integrations/trainerize-api-mcp-server/summarize-weekly-check-ins)** (runs: weekly): "Summarize the check-in forms submitted since last Monday. Flag anyone whose energy or motivation score dropped, anyone who mentions pain, and list who has not checked in." → `list_check_ins`, `get_client`, `list_clients`
- **[Assign the next program when a client's program expires](https://cotlet.dev/integrations/trainerize-api-mcp-server/assign-next-program-when-program-expires)** (runs: weekly): "Find clients whose main program ends in the next week or already ended. Suggest the next master program for each based on their goal and last check-in, and subscribe them after I approve, starting the day after the old one ends." → `list_clients`, `get_client`, `list_check_ins`, `list_master_programs`, `subscribe_to_program`
- **Book recurring appointments** (runs: weekly): "Book a 1-on-1 with Sam every Tuesday at 7:00 for the next month." → `list_clients`, `list_appointments`, `schedule_appointment`
- **[Draft replies to client messages](https://cotlet.dev/integrations/trainerize-api-mcp-server/reply-to-client-messages)** (runs: daily): "Go through my unread Trainerize messages from today, check each client's program before answering, and draft replies I can approve one by one. Flag anything about pain or payments for me." → `list_conversations`, `get_conversation`, `get_client`, `send_message`
- **Log body stats after a session**: "Enter the weight and waist I measured for Alex at today's session." → `list_clients`, `log_body_stats`

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

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

### list_clients

Clients with client type, trainer, tags and last activity. Access: read. REST: `POST /api/v1/trainerize/list_clients`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_type` | enum | no | full_access, offline, basic, prospect, pending or deactivated. Default: all except deactivated. |
| `tag` | string | no | Only clients with this custom or auto client tag. |
| `search` | string | no | Match on name or email. |
| `limit` | integer | no | 1 to 200. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the clients you can see, in the order Trainerize shows them. Deactivated clients are left out unless you ask for them with client_type. Filter by tag to get a group, or search by name or email. Pages hold up to 200 clients; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "clients": [
    {
      "client_id": "4821937",
      "name": "Alex Rivera",
      "email": "alex@example.com",
      "client_type": "full_access",
      "trainer": "yourname",
      "tags": [
        "Challenge"
      ],
      "last_active": "2026-10-08T17:40:00Z"
    },
    {
      "client_id": "4821944",
      "name": "Sam Carter",
      "email": "sam@example.com",
      "client_type": "full_access",
      "trainer": "yourname",
      "tags": [
        "Challenge",
        "Online"
      ],
      "last_active": "2026-10-09T06:12:00Z"
    }
  ],
  "next_cursor": null
}
```

### get_client

Client profile: contact, client type, trainer, tags, goals, and main and add-on programs. Access: read. REST: `POST /api/v1/trainerize/get_client`.

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

Returns one client profile with contact details, client type, trainer, tags, goals and the main and add-on programs the client is on. Use it before a message or a program change to see where the client stands.

Example response:

```json
{
  "client_id": "4821937",
  "name": "Alex Rivera",
  "email": "alex@example.com",
  "client_type": "full_access",
  "trainer": "yourname",
  "tags": [
    "Challenge"
  ],
  "goals": [
    "Lose 5 kg",
    "Run 5 km"
  ],
  "main_program": {
    "program_id": "552012",
    "name": "4-week Base"
  },
  "add_on_programs": []
}
```

### get_body_stats

Body weight, body fat, body measurements and caliper entries for a date range. Access: read. REST: `POST /api/v1/trainerize/get_body_stats`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from list_clients. |
| `from` | date | no | Start date. Default: 90 days ago. |
| `to` | date | no | End date. Default: today. |

Returns the entries a client logged in the range, oldest first, grouped by date. Default range is the last 90 days.

Example response:

```json
{
  "client_id": "4821937",
  "entries": [
    {
      "date": "2026-09-12",
      "body_weight": 84.1,
      "waist": 90
    },
    {
      "date": "2026-09-26",
      "body_weight": 83.2,
      "waist": 89
    }
  ]
}
```

### list_check_ins

Check-in forms a client submitted, with each question and answer. Access: read. REST: `POST /api/v1/trainerize/list_check_ins`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | no | One client. Default: all clients. |
| `since` | date | no | Only check-ins submitted on or after this date. |

Lists submitted check-in forms, newest first, each with every question and the answer. Leave client_id empty to read all clients. Use since to read only what is new since your last run.

Example response:

```json
{
  "check_ins": [
    {
      "check_in_id": "7710342",
      "client_id": "4821937",
      "client_name": "Alex Rivera",
      "submitted_at": "2026-10-06T08:15:00Z",
      "answers": [
        {
          "question": "How is your energy this week?",
          "answer": "2 out of 5"
        },
        {
          "question": "Anything getting in the way?",
          "answer": "Two late shifts, skipped Thursday."
        }
      ]
    }
  ]
}
```

### list_conversations

Your message conversations with clients and groups, newest first, with unread count. Access: read. REST: `POST /api/v1/trainerize/list_conversations`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `unread_only` | boolean | no | Only conversations with unread messages. |
| `limit` | integer | no | 1 to 100. Default: 30. |

Lists your conversations in the Trainerize messenger, newest first, with the other person or group, unread count and a preview of the last message. Set unread_only to see only what needs an answer.

Example response:

```json
{
  "conversations": [
    {
      "conversation_id": "3390127",
      "with": {
        "client_id": "4821937",
        "name": "Alex Rivera"
      },
      "unread": 1,
      "last_message": "Can I swap lunges for something easier on my knee?",
      "updated_at": "2026-10-10T07:02:00Z"
    }
  ]
}
```

### get_conversation

Messages in one conversation, with sender, time and attachment names. Access: read. REST: `POST /api/v1/trainerize/get_conversation`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `conversation_id` | string | yes | Conversation ID from list_conversations. |
| `limit` | integer | no | Most recent messages, 1 to 200. Default: 50. |

Returns the most recent messages of one conversation, oldest first, so your agent reads the thread in order. Attachments are listed by file name only.

Example response:

```json
{
  "conversation_id": "3390127",
  "messages": [
    {
      "from": "Alex Rivera",
      "body": "Can I swap lunges for something easier on my knee?",
      "sent_at": "2026-10-10T07:02:00Z",
      "attachments": []
    }
  ]
}
```

### list_master_programs

Master programs in your library, with program tags and subscriber count. Access: read. REST: `POST /api/v1/trainerize/list_master_programs`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Match on program name. |

Lists the master programs in your library, with tags and how many clients are subscribed. Use the program_id with subscribe_to_program.

Example response:

```json
{
  "programs": [
    {
      "program_id": "552031",
      "name": "6-week Shred",
      "tags": [
        "fat loss"
      ],
      "subscribers": 14
    },
    {
      "program_id": "552012",
      "name": "4-week Base",
      "tags": [
        "beginner"
      ],
      "subscribers": 31
    }
  ]
}
```

### list_appointments

Appointments on the schedule for a date range, with type, trainer and client. Access: read. REST: `POST /api/v1/trainerize/list_appointments`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | yes | Start date. |
| `to` | date | yes | End date. |
| `trainer_id` | string | no | Admins and managers: another trainer. Default: you. |

Lists appointments in the range, earliest first, with type, trainer and client. Admins and managers can read another trainer's schedule with trainer_id; other roles see their own.

Example response:

```json
{
  "appointments": [
    {
      "appointment_id": "90311102",
      "client_id": "4821944",
      "appointment_type": "1-on-1 Appointment",
      "start": "2026-10-13T08:00:00-04:00",
      "end": "2026-10-13T09:00:00-04:00",
      "trainer": "yourname"
    }
  ]
}
```

### send_message

Send a message to a client as you in the Trainerize messenger. Access: write, asks the user first. REST: `POST /api/v1/trainerize/send_message`.

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

Sends a message to one client in the Trainerize messenger under your name. The client sees it in the app. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "conversation_id": "3390127",
  "message_id": "88120045",
  "status": "sent",
  "sent_at": "2026-10-10T09:05:00-04:00"
}
```

### subscribe_to_program

Subscribe one or more clients to a master program from a start date. Access: write, asks the user first. REST: `POST /api/v1/trainerize/subscribe_to_program`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `program_id` | string | yes | Program ID from list_master_programs. |
| `client_ids` | string[] | yes | Clients to subscribe. |
| `start_date` | date | yes | First day of the program. |
| `program_type` | enum | no | main or add_on. Default: main. |

Subscribes the clients to a master program as their main program or as an add-on, starting on the date you give. The program appears in each client's app. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "program_id": "552031",
  "program_type": "main",
  "start_date": "2026-10-19",
  "subscribed": [
    {
      "client_id": "4821937",
      "status": "subscribed"
    },
    {
      "client_id": "4821944",
      "status": "subscribed"
    }
  ]
}
```

### log_body_stats

Enter body stats for a client on a date, in the client's units. Access: write, asks the user first. REST: `POST /api/v1/trainerize/log_body_stats`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from list_clients. |
| `date` | date | yes | Day of the measurement. |
| `stats` | object | yes | Any of body_weight, body_fat_percent, waist, hips, chest, neck and other body measurements. |

Enters body stats for one client on one date, in the client's units. The entry shows in the client's progress. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "client_id": "4821937",
  "date": "2026-10-10",
  "status": "logged",
  "stats": {
    "body_weight": 82.4,
    "waist": 88
  }
}
```

### schedule_appointment

Book an appointment with a client, optionally weekly or monthly. Access: write, asks the user first. REST: `POST /api/v1/trainerize/schedule_appointment`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from list_clients. |
| `appointment_type` | string | yes | Appointment type name, e.g. 1-on-1 Appointment. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `repeat` | enum | no | none, weekly or monthly. Default: none. |
| `repeat_until` | date | no | Last date of a repeating appointment. |
| `notes` | string | no | Appointment notes. The client can see them. |

Books an appointment of the type you name, with the client, at the start time you give. A weekly or monthly repeat creates one appointment per date up to repeat_until. Notes are visible to the client. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "appointment_id": "90311284",
  "client_id": "4821937",
  "appointment_type": "1-on-1 Appointment",
  "start": "2026-10-13T07:00:00-04:00",
  "end": "2026-10-13T08:00:00-04:00",
  "repeat": "weekly",
  "occurrences": 5,
  "trainer": "yourname"
}
```

### add_client_tags

Add custom client tags to one or more clients. Access: write, asks the user first. REST: `POST /api/v1/trainerize/add_client_tags`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_ids` | string[] | yes | Clients to tag. |
| `tags` | string[] | yes | Existing custom client tag names. |

Adds existing custom client tags to the clients. Tags group clients for list_clients and for your own filters in Trainerize. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "tags": [
    "Challenge"
  ],
  "tagged": [
    "4821937",
    "4821944"
  ],
  "status": "tagged"
}
```

### set_client_status

Deactivate a client (they lose app access, history is kept) or reactivate them. Access: write, asks the user first. REST: `POST /api/v1/trainerize/set_client_status`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `client_id` | string | yes | Client ID from list_clients. |
| `status` | enum | yes | deactivated or active. |

Deactivates a client, who then loses access to the app while the history is kept, or reactivates a deactivated one. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "client_id": "4821944",
  "status": "deactivated"
}
```

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

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

### Connect Trainerize to your agent.

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

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

```
Find my full-access clients whose last body stats entry is more than two weeks old and draft a short check-in message for each. Leave out anyone who told me they are sick or traveling.
```

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

```
curl https://cotlet.dev/api/v1/trainerize/schedule_appointment \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"client_id":"4821937","appointment_type":"1-on-1 Appointment","start":"2026-10-13T07:00:00-04:00","repeat":"weekly","repeat_until":"2026-11-10"}'
```

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

```
{
  "appointment_id": "90311284",
  "client_id": "4821937",
  "appointment_type": "1-on-1 Appointment",
  "start": "2026-10-13T07:00:00-04:00",
  "end": "2026-10-13T08:00:00-04:00",
  "repeat": "weekly",
  "occurrences": 5,
  "trainer": "yourname"
}
```

## Why use Cotlet for Trainerize?

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

## Is there a Trainerize MCP server on GitHub?

No open-source Trainerize MCP server turned up. Zapier works on paid Trainerize plans and its MCP server can create clients, assign programs and send messages, but it cannot read messages, progress, check-ins or appointments.

|  | Zapier | Cotlet |
|---|---|---|
| Setup | Connect Trainerize in a Zapier account, then add Zapier MCP to your agent | Request access, sign in to Trainerize once in your browser, add one MCP server or API key |
| Reading data | Find a client by email; events arrive as triggers | Clients, messages, body stats, check-ins, programs and appointments |
| Write actions | Clients, tags, groups, programs, messages and files | Clients, tags, programs, messages, appointments and body stats, with your OK on each by default |
| When Trainerize changes | Zapier maintains its app | Our team tests it daily and fixes it for you; failed calls are free |
| When the session expires | Reconnect the account in Zapier | Your agent gets a link to sign in again |
| Where it runs | Zapier cloud, any MCP client | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | Free tier with limits, then a paid Zapier plan | Free 7-day trial with 5,000 credits, then credits per call |

### Which one fits you

**Pick Cotlet if**

- you are not a developer, or you do not want to maintain a server
- you need it to keep working when Trainerize 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 Trainerize API cost?

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

**Do I need to be technical?**

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

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

**Do I need a Studio or Enterprise plan?**

No. Cotlet works in your own Trainerize account and does not use the API, which Trainerize limits to Studio and Enterprise plans or the FitMetrics add-on (checked 10 Oct 2026). Some tools depend on your role: reading another trainer's schedule needs an admin or manager.

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

No. Every call to send_message, subscribe_to_program, log_body_stats, schedule_appointment, add_client_tags or set_client_status 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 Trainerize 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/trainerize/{tool} from the HTTP Request node.