# ThriveCart API and MCP server

> ThriveCart has an official API, but it is limited (checked 11 Oct 2026). It reads products, transactions, customers and affiliates, and it can refund, pause, resume and cancel subscriptions and approve affiliates. It has no endpoints for coupons (listed as "Coming soon" in the developer docs) and none to create, clone, change or archive products. We found no official MCP server.

Checkout and cart platform for creators selling courses, digital and physical products and subscriptions, with order bumps, upsells, coupons and an affiliate program.

## What is the ThriveCart API?

Cotlet's ThriveCart API exposes 15 endpoints for your own ThriveCart account: list products, get product, list transactions, list subscriptions, list coupons, list affiliates, create coupon, update coupon, clone product, set product status, refund transaction, pause subscription, cancel subscription, approve affiliate and set affiliate commission. The list_products endpoint returns products in your account with type, status and ID. Each endpoint takes simple JSON inputs like product_id, status or query 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:** 15 (6 read, 9 write)
- **Updated:** 2026-10-11

ThriveCart has an official API, but it is limited (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for ThriveCart with 15 endpoints (6 read, 9 write): your AI agent signs in as you and does the work.

## Does ThriveCart have an official API?

ThriveCart has an official API, but it is limited (checked 11 Oct 2026). It reads products, transactions, customers and affiliates, and it can refund, pause, resume and cancel subscriptions and approve affiliates. It has no endpoints for coupons (listed as "Coming soon" in the developer docs) and none to create, clone, change or archive products. We found no official MCP server.

| Task | ThriveCart official | Cotlet |
|---|---|---|
| Create coupons | No: Create & manage coupons is "Coming soon" in the docs | Yes |
| Edit, enable or disable coupons | No | Yes |
| Clone a product | No: Products are read only | Yes |
| Set product status or archive a product | No | Yes |
| List subscriptions with status, MRR and yearly revenue | Partly: One customer at a time, by email | Yes |
| Refund a payment | Yes: Per transaction or rebill, with an internal reason | Yes |
| Pause, resume or cancel a subscription | Yes: Pause can resume automatically at least 24 hours later | Yes |
| Approve affiliates and set custom commissions | Yes | Yes |

Sources: [ThriveCart developer documentation](https://developers.thrivecart.com/documentation/), [ThriveCart PHP SDK (official, method list)](https://github.com/thrivecart/php-api), [ThriveCart help: creating a coupon](https://support.thrivecart.com/help/creating-a-coupon/), [ThriveCart help: your customers' subscriptions](https://support.thrivecart.com/help/your-customers-subscriptions/)

## For AI agents

```text
ThriveCart has an official API, but it is limited (checked 11 Oct 2026). It reads products, transactions, customers and affiliates, and it can refund, pause, resume and cancel subscriptions and approve affiliates. It has no endpoints for coupons (listed as "Coming soon" in the developer docs) and none to create, clone, change or archive products. We found no official MCP server.
Cotlet provides a hosted MCP server and REST API for ThriveCart: 15 tools (6 read, 9 write).
Access       Request access at https://cotlet.dev/app/signup?app=thrivecart; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/thrivecart
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_products, get_product, list_transactions, list_subscriptions, list_coupons, list_affiliates, create_coupon, update_coupon, clone_product, set_product_status, refund_transaction, pause_subscription, cancel_subscription, approve_affiliate, set_affiliate_commission
Confirm      create_coupon, update_coupon, set_product_status, refund_transaction, pause_subscription, cancel_subscription, approve_affiliate, set_affiliate_commission (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/thrivecart-api-mcp-server.md

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

## What can an AI agent do in ThriveCart?

Cotlet is best for ThriveCart sellers who run launches, coupons and affiliates and want their AI agent to do the clicking without running or fixing a server.

- **[Create coupons for a sale and retire old ones](https://cotlet.dev/integrations/thrivecart-api-mcp-server/create-discount-coupons)** (runs: weekly): "Set up a BLACKFRIDAY coupon in ThriveCart: 30% off the Landing Page Course and its bumps, 27 Nov to 1 Dec, first 100 uses. Check the code is free and disable any old sale codes on that product that have no end date." → `list_products`, `get_product`, `list_coupons`, `create_coupon`, `update_coupon`
- **Review coupon usage and switch off old coupons** (runs: weekly): "Which coupons were used most, and disable the ones I no longer need." → `list_coupons`, `update_coupon`
- **[Clone a product for a new cohort and retire the old checkout](https://cotlet.dev/integrations/thrivecart-api-mcp-server/clone-product-for-new-cohort)**: "Clone my Spring Workshop product in ThriveCart for the autumn cohort, add the copy to the coupons and tell me what else needs changing, then archive the spring product once I confirm." → `list_products`, `get_product`, `clone_product`, `list_coupons`, `update_coupon`, `set_product_status`
- **[Review overdue and paused subscriptions](https://cotlet.dev/integrations/thrivecart-api-mcp-server/track-overdue-subscriptions)** (runs: weekly): "Every Monday, list my overdue ThriveCart subscriptions with how long each has been overdue and how much MRR is at risk, check which paused ones resume this month, and suggest what to do with each." → `list_subscriptions`, `list_transactions`, `pause_subscription`, `cancel_subscription`
- **[Refund a customer and cancel their subscription](https://cotlet.dev/integrations/thrivecart-api-mcp-server/refund-and-cancel-subscription)**: "client@example.com asked for a refund within the 30-day guarantee. Refund their last ThriveCart payment, cancel the subscription so they are not billed again, and send them the final invoice." → `list_transactions`, `list_subscriptions`, `refund_transaction`, `cancel_subscription`
- **Approve affiliate applications** (runs: daily): "Approve every pending affiliate for my main course and give them 40%." → `list_affiliates`, `approve_affiliate`, `set_affiliate_commission`

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

Yes. Cotlet does not replace your automation platform: it gives it a ThriveCart 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 create coupons for a sale and retire old ones, 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/thrivecart/{tool}. | Schedule Trigger node. |
| Make | HTTP module: POST https://cotlet.dev/api/v1/thrivecart/{tool} with an Authorization: Bearer header and a JSON body. | Scenario schedule. |
| Zapier | Webhooks by Zapier: POST https://cotlet.dev/api/v1/thrivecart/{tool} with the same header and body. | Schedule by Zapier trigger. |
| Your own script | POST https://cotlet.dev/api/v1/thrivecart/{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 ThriveCart.

### list_products

Products in your account with type, status and ID. Access: read. REST: `POST /api/v1/thrivecart/list_products`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | live, test, disabled, archived, active (all but archived) or all. Default: active. |
| `search` | string | no | Part of the product name. |

Lists the products of your account with name, type, status and ID. Filter by status the way the Products page does; the default is Active, which holds live, test and disabled products and leaves out archived ones. Use the product_id of each item in the other tools.

Example response:

```json
{
  "products": [
    {
      "product_id": "12",
      "name": "Landing Page Course",
      "type": "digital",
      "status": "live"
    },
    {
      "product_id": "15",
      "name": "Spring Workshop",
      "type": "digital",
      "status": "disabled"
    }
  ]
}
```

### get_product

One product with its pricing options, bumps, upsells and downsells. Access: read. REST: `POST /api/v1/thrivecart/get_product`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `product_id` | string | yes | Product ID from list_products. |

Returns one product with its pricing options and the bumps, upsells and downsells in its funnel, each with its own ID and price. Use it to pick the product_ids for a coupon or an affiliate.

Example response:

```json
{
  "product_id": "12",
  "name": "Landing Page Course",
  "status": "live",
  "pricing_options": [
    {
      "id": "po_1",
      "name": "One-time",
      "amount": "197.00",
      "currency": "USD"
    },
    {
      "id": "po_2",
      "name": "Monthly",
      "amount": "49.00",
      "currency": "USD"
    }
  ],
  "bumps": [
    {
      "bump_id": "31",
      "name": "Template pack",
      "amount": "27.00"
    }
  ],
  "upsells": [],
  "downsells": []
}
```

### list_transactions

Payments, rebills, refunds and cancellations with customer, product, amount and invoice ID. Access: read. REST: `POST /api/v1/thrivecart/list_transactions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `query` | string | no | Customer name or email, order ID or invoice ID. |
| `type` | enum | no | any, charge, rebill, refund or cancel. Default: any. |
| `per_page` | integer | no | 1 to 100. Default: 50. |
| `page` | integer | no | Page number, starting at 1. Default: 1. |

Searches your transactions by customer name, email, order ID or invoice ID, and by type. Pages hold up to 100 transactions; pass page to read on. Use the transaction_id of an item in refund_transaction and the subscription_id of a rebill in pause_subscription or cancel_subscription.

Example response:

```json
{
  "transactions": [
    {
      "transaction_id": "tx_20418",
      "type": "charge",
      "customer": {
        "name": "Dana Client",
        "email": "client@example.com"
      },
      "product": "Landing Page Course",
      "amount": "97.00",
      "currency": "USD",
      "invoice_id": "INV-20418",
      "subscription_id": "sub_7731",
      "date": "2026-10-02"
    }
  ],
  "page": 1,
  "has_more": false
}
```

### list_subscriptions

Subscriptions with status and next payment, plus the count, monthly recurring revenue and yearly revenue of the filter. Access: read. REST: `POST /api/v1/thrivecart/list_subscriptions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | new_signups, trial, active, cancelled, cancelled_still_active, paused, completed, overdue or all. Default: active. |
| `product_id` | string | no | Only this product. |
| `query` | string | no | Customer name or email. |

Returns the subscriptions that match your filter, as the Subscriptions dashboard does, plus the number of matches and their monthly recurring revenue and yearly revenue. Use it to see how much paused or overdue subscriptions cost you. Cancelled (still active) means the customer cancelled renewals but has access until the last paid date.

Example response:

```json
{
  "subscriptions": [
    {
      "subscription_id": "sub_7731",
      "customer": "Dana Client",
      "product": "Landing Page Course",
      "status": "overdue",
      "amount": "49.00",
      "currency": "USD",
      "billing": "monthly",
      "next_payment": "2026-10-05"
    },
    {
      "subscription_id": "sub_7802",
      "customer": "Sam Rivers",
      "product": "Membership",
      "status": "overdue",
      "amount": "97.00",
      "currency": "USD",
      "billing": "monthly",
      "next_payment": "2026-10-08"
    }
  ],
  "total": 2,
  "mrr": "146.00",
  "yearly_revenue": "1752.00",
  "currency": "USD"
}
```

### list_coupons

Coupons with code, discount, status, dates, products and number of uses. Access: read. REST: `POST /api/v1/thrivecart/list_coupons`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `search` | string | no | Part of the coupon name or code. |

Lists the coupons of the Coupons area with code, discount, status, redeemable dates, the products they work on and how many times each was used. Use the coupon_id of each item in update_coupon.

Example response:

```json
{
  "coupons": [
    {
      "coupon_id": "87",
      "name": "Black Friday 30% main course",
      "code": "BLACKFRIDAY",
      "status": "enabled",
      "discount": "30%",
      "starts_on": "2026-11-27",
      "ends_on": "2026-12-01",
      "max_uses": 100,
      "uses": 0,
      "product_ids": [
        "12"
      ]
    },
    {
      "coupon_id": "71",
      "name": "Spring 20% off",
      "code": "SPRING20",
      "status": "enabled",
      "discount": "20%",
      "starts_on": null,
      "ends_on": null,
      "max_uses": null,
      "uses": 14,
      "product_ids": [
        "15"
      ]
    }
  ]
}
```

### list_affiliates

Affiliates with their approval status per product. Access: read. REST: `POST /api/v1/thrivecart/list_affiliates`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `product_id` | string | no | Only affiliates of this product. |
| `query` | string | no | Affiliate name, email or affiliate ID. |
| `page` | integer | no | Page number, starting at 1. Default: 1. |

Lists your affiliates with contact details and, for each product, whether the affiliate is approved or pending. Pages hold up to 25 affiliates; pass page to read on. Use the affiliate_id of an item in approve_affiliate and set_affiliate_commission.

Example response:

```json
{
  "affiliates": [
    {
      "affiliate_id": "3481",
      "name": "Jo Partner",
      "email": "jo@example.com",
      "products": [
        {
          "product_id": "12",
          "status": "pending"
        }
      ]
    }
  ],
  "page": 1,
  "has_more": false
}
```

### create_coupon

New coupon with a fixed or percentage discount, dates, use limit and products. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/create_coupon`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Internal name. |
| `code` | string | yes | At least 3 characters, letters and digits only. |
| `discount_type` | enum | yes | fixed or percentage. |
| `discount` | string | yes | Amount or percent, decimals allowed for percent, e.g. 20 or 12.5. |
| `applies_to` | enum | no | Percentage only: funnel, main_product, bumps_only or main_and_bumps. Default: main_product. |
| `apply_to_recurring` | boolean | no | Percentage only: also discount recurring payments. |
| `product_ids` | string[] | no | Products it works on. Default: all products. |
| `starts_on` | date | no | First day it works. Default: now. |
| `ends_on` | date | no | Last day it works, until 23:59:59 in your account time zone. |
| `max_uses` | integer | no | Disable after this many uses in total. |
| `affiliate_id` | string | no | Credit this affiliate on every use. |

Creates a coupon the way the Coupons area does. The code needs at least 3 characters, letters and digits only. A percentage coupon can apply to the funnel, the main product, bumps only or the main product plus bumps; a fixed coupon applies to the main product only, once. max_uses counts all uses together, not per customer. The coupon is enabled when created, so buyers can use it from the start date. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "coupon_id": "87",
  "name": "Black Friday 30% main course",
  "code": "BLACKFRIDAY",
  "status": "enabled",
  "discount": "30%",
  "applies_to": "main_product",
  "product_ids": [
    "12"
  ],
  "starts_on": "2026-11-27",
  "ends_on": "2026-12-01",
  "max_uses": 100,
  "uses": 0
}
```

### update_coupon

Enable or disable a coupon, or change its discount, dates, use limit or products. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/update_coupon`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `coupon_id` | string | yes | Coupon ID from list_coupons. |
| `fields` | object | yes | Any of status (enabled or disabled), discount, starts_on, ends_on, max_uses, product_ids. |

Changes one coupon. Disabling keeps the coupon and enabling turns it back on. Discount, dates and the use limit apply to the next buyer. If you add bumps to a product after creating a coupon, send product_ids again, because new bumps are not added automatically. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "coupon_id": "71",
  "code": "SPRING20",
  "status": "disabled",
  "discount": "20%",
  "uses": 14
}
```

### clone_product

Copy a product with its checkout and settings, e.g. for a new cohort. Access: write. REST: `POST /api/v1/thrivecart/clone_product`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `product_id` | string | yes | Product ID from list_products. |
| `name` | string | no | Name for the copy. Default: ThriveCart's default for a copy. |

Copies a product the way the copy button does, including archived products. Only the account owner can clone; for a sub-user the call fails with a permission error. The copy is a separate product with its own ID, ready for you to edit. clone_product runs without asking first: it sends nothing to anyone, and set_product_status archives the copy in one call.

Example response:

```json
{
  "product_id": "27",
  "name": "Spring Workshop, autumn cohort",
  "cloned_from": "15"
}
```

### set_product_status

Switch a product between live, test and disabled, or archive or restore it. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/set_product_status`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `product_id` | string | yes | Product ID from list_products. |
| `status` | enum | yes | live, test, disabled, archived or restored. |

Sets the status of a product. Live products can be bought, test products are in test mode, disabled products are inactive. Archiving removes a product from the active list and disables its checkout, while its stats and transactions stay in your reports; restoring makes it active again. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "product_id": "15",
  "name": "Spring Workshop",
  "status": "archived"
}
```

### refund_transaction

Full or partial refund of one payment, with an internal note. Does not cancel the subscription. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/refund_transaction`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `transaction_id` | string | yes | Transaction ID from list_transactions. |
| `amount` | string | no | Partial amount. Default: the full remaining amount. |
| `note` | string | no | Internal note, never shown to the customer. |

Refunds one payment or rebill, in full or in part. You can refund partly several times, up to the transaction total and never more. A refund cannot be reversed, and the note stays internal. It does not cancel the subscription, so call cancel_subscription too. A PayPal refund fails if your PayPal account has too little balance. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "transaction_id": "tx_20418",
  "status": "refunded",
  "amount": "97.00",
  "refunded_total": "97.00",
  "remaining": "0.00",
  "currency": "USD"
}
```

### pause_subscription

Pause billing indefinitely, for a number of billing periods or until a date. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/pause_subscription`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `subscription_id` | string | yes | Subscription ID from list_subscriptions. |
| `resume_on` | date | no | Resume automatically on this date, at least 24 hours from now. |
| `periods` | integer | no | Pause for this many billing periods instead. |

Pauses billing of one subscription. Without resume_on or periods the pause lasts until you resume it. Pausing does not remove payments the customer owes: a subscription with 5 rebills is still charged 5 times, later. resume_on must be at least 24 hours ahead. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "subscription_id": "sub_7731",
  "status": "paused",
  "resume_on": "2026-11-15"
}
```

### cancel_subscription

Stop all future payments of a subscription. Cannot be undone. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/cancel_subscription`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `subscription_id` | string | yes | Subscription ID from list_subscriptions. |

Cancels one active or paused subscription for good. ThriveCart tells the payment processor, tags the original transaction as cancelled and adds a $0.00 transaction on that day to mark it. It does not refund anything. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "subscription_id": "sub_7731",
  "status": "cancelled",
  "cancelled_on": "2026-10-11"
}
```

### approve_affiliate

Approve or reject a pending affiliate application for one or more products. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/approve_affiliate`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `affiliate_id` | string | yes | Affiliate ID from list_affiliates. |
| `product_ids` | string[] | yes | Product IDs to decide on. |
| `decision` | enum | yes | approve or reject. |
| `trigger_emails` | boolean | no | Send ThriveCart's emails to the affiliate and you. |

Approves or rejects an affiliate for the products you name. Approving needs a pending application for each of them. An affiliate approved for the main product is also approved for the upsells and downsells of its funnel. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "affiliate_id": "3481",
  "name": "Jo Partner",
  "products": [
    {
      "product_id": "12",
      "status": "approved"
    }
  ]
}
```

### set_affiliate_commission

Custom commission for one affiliate on one product. Access: write, asks the user first. REST: `POST /api/v1/thrivecart/set_affiliate_commission`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `affiliate_id` | string | yes | Affiliate ID from list_affiliates. |
| `product_id` | string | yes | Product ID from list_products. |
| `type` | enum | yes | percentage or fixed. |
| `amount` | string | yes | Percent or amount, e.g. 40. |
| `recurring_type` | enum | no | percentage or fixed, for recurring payments. |
| `recurring_amount` | string | no | Percent or amount for recurring payments. |

Sets a custom commission for one approved affiliate on one product, instead of the default rate. It applies to all pricing options of the product, not to single ones. Upfront and recurring commissions are set separately. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "affiliate_id": "3481",
  "product_id": "12",
  "upfront": {
    "type": "percentage",
    "amount": "40"
  }
}
```

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

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

### Connect ThriveCart to your agent.

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

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

```
Set up a BLACKFRIDAY coupon in ThriveCart: 30% off the Landing Page Course and its bumps, 27 Nov to 1 Dec, first 100 uses. Check the code is free and disable any old sale codes on that product that have no end date.
```

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

```
curl https://cotlet.dev/api/v1/thrivecart/create_coupon \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"Black Friday 30% main course","code":"BLACKFRIDAY","discount_type":"percentage","discount":"30","applies_to":"main_product","product_ids":["12"],"starts_on":"2026-11-27","ends_on":"2026-12-01","max_uses":100}'
```

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

```
{
  "coupon_id": "87",
  "name": "Black Friday 30% main course",
  "code": "BLACKFRIDAY",
  "status": "enabled",
  "discount": "30%",
  "applies_to": "main_product",
  "product_ids": [
    "12"
  ],
  "starts_on": "2026-11-27",
  "ends_on": "2026-12-01",
  "max_uses": 100,
  "uses": 0
}
```

## Why use Cotlet for ThriveCart?

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

## Is there a ThriveCart MCP server on GitHub?

Yes. A community ThriveCart MCP server exists on GitHub, maintained by one person. You install it on your own computer, create an API key in ThriveCart and keep it running yourself. It is built on the official API, so it stops where the API stops: no coupons, no product cloning or archiving. Cotlet hosts the same kind of server for you, adds those tools, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Install the package, create an API key in ThriveCart Settings, add it to each MCP client | Request access, sign in to ThriveCart once, add one MCP server or API key |
| Coupons and products | Limited to what the official API offers: no coupons, no cloning, no archiving | Create and edit coupons, clone products, set status and archive |
| When ThriveCart 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 ThriveCart access | An API key in a config file on your computer, readable by any program you run; it works until you revoke it | Session encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When the session expires | Nothing to renew: the key stays valid until you revoke it | We keep it alive; if ThriveCart 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, paid for with your time | 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 ThriveCart 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 ThriveCart API cost?

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

**Do I need to be technical?**

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

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

**Who can clone products?**

Only the account owner. In ThriveCart the clone and create-new-product buttons are greyed out for sub-users, so clone_product needs an owner login.

**When does a coupon start and stop?**

A coupon with a start date works from 00:01 on that day, and one with an end date stops after 23:59:59 on that day. Both follow your ThriveCart time zone settings.

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

No. Every call to create_coupon, update_coupon, set_product_status, refund_transaction, pause_subscription, cancel_subscription, approve_affiliate or set_affiliate_commission waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. clone_product runs without asking, because it sends nothing to anyone and one call undoes it.

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