# Systeme.io API and MCP server

> Yes, Systeme.io has a public API and an official MCP server, covering contacts, tags, newsletters, email campaigns, funnels, price plans, coupons, products, courses and subscriptions (checked 11 Oct 2026). Neither one lists transactions, refunds sales, sends invoices, manages blog posts or edits text on an existing funnel page.

All-in-one platform for online businesses: sales funnels, email marketing, online courses, blogs and an affiliate program.

## What is the Systeme.io API?

Cotlet's Systeme.io API exposes 13 endpoints for your own Systeme.io account: list transactions, get transaction, export transactions, list funnel steps, get page content, list blog posts, update page text, duplicate funnel step, remove funnel step, refund transaction, send invoice, create blog post and activate blog post. The list_transactions endpoint returns sales from the Transactions page, with customer, offer, amount and transaction type. Each endpoint takes simple JSON inputs like step_id, transaction_id or from 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:** 13 (6 read, 7 write)
- **Updated:** 2026-10-11

Yes, Systeme.io has a public API and an official MCP server, covering contacts, tags, newsletters, email campaigns, funnels, price plans, coupons, products, courses and subscriptions (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Systeme.io with 13 endpoints (6 read, 7 write): your AI agent signs in as you and does the work.

## Does Systeme.io have an official API?

Yes, Systeme.io has a public API and an official MCP server, covering contacts, tags, newsletters, email campaigns, funnels, price plans, coupons, products, courses and subscriptions (checked 11 Oct 2026). Neither one lists transactions, refunds sales, sends invoices, manages blog posts or edits text on an existing funnel page.

| Task | Systeme.io official | Cotlet |
|---|---|---|
| List and filter transactions | Partly: Webhooks for new and canceled sales and a subscriptions list, no transaction history | Yes |
| Export transactions to CSV | No | Yes |
| Refund a transaction | No | Yes |
| Send an invoice to a customer | No | Yes |
| List funnels and their steps | Yes: Public API and official MCP server | Yes |
| Edit text on an existing funnel page | Partly: The API saves whole page content; the MCP server regenerates whole webinar pages | Yes |
| Duplicate or delete funnel steps | No | Yes |
| Create and activate blog posts | No | Yes |

Sources: [Systeme.io Help: how to use the MCP server](https://help.systeme.io/article/9489-how-to-use-systeme-ios-mcp), [Systeme.io Public API reference (index)](https://developer.systeme.io/llms.txt), [Systeme.io Help: how to refund your customer](https://help.systeme.io/article/259-how-to-refund-a-customer), [Systeme.io Help: how to send an invoice to a client](https://help.systeme.io/article/318-how-to-send-an-invoice-to-a-client)

## For AI agents

```text
Yes, Systeme.io has a public API and an official MCP server, covering contacts, tags, newsletters, email campaigns, funnels, price plans, coupons, products, courses and subscriptions (checked 11 Oct 2026). Neither one lists transactions, refunds sales, sends invoices, manages blog posts or edits text on an existing funnel page.
Cotlet provides a hosted MCP server and REST API for Systeme.io: 13 tools (6 read, 7 write).
Access       Request access at https://cotlet.dev/app/signup?app=systeme-io; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/systeme-io
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_transactions, get_transaction, export_transactions, list_funnel_steps, get_page_content, list_blog_posts, update_page_text, duplicate_funnel_step, remove_funnel_step, refund_transaction, send_invoice, create_blog_post, activate_blog_post
Confirm      update_page_text, remove_funnel_step, refund_transaction, send_invoice, activate_blog_post (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/systeme-io-api-mcp-server.md

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

## What can an AI agent do in Systeme.io?

Cotlet is best for Systeme.io sellers who handle refunds, invoices, funnel page changes and blog posts by hand and want their AI agent to do it without running or fixing a server.

- **[Refund a customer and send the refund invoice](https://cotlet.dev/integrations/systeme-io-api-mcp-server/refund-customer-and-send-invoice)**: "Ana (ana@example.com) wants her money back for the Starter course she bought yesterday. Refund it and email her the refund invoice." → `list_transactions`, `get_transaction`, `refund_transaction`, `send_invoice`
- **[Monthly sales report by country and customer type](https://cotlet.dev/integrations/systeme-io-api-mcp-server/sales-report-by-country)** (runs: monthly): "On the 1st of every month, give me last month's Systeme.io sales by country, split into companies and individuals, with refunds on their own line." → `list_transactions`, `export_transactions`
- **[Update text across funnel pages](https://cotlet.dev/integrations/systeme-io-api-mcp-server/update-funnel-page-text)**: "Our launch offer now ends Sunday 19 Oct instead of Friday 17 Oct. Change it on every page of my Course launch funnel and show me each change first." → `list_funnel_steps`, `get_page_content`, `update_page_text`, `duplicate_funnel_step`
- **Duplicate a funnel page to test a new offer**: "Duplicate my webinar sales page as webinar-b so I can test a new offer." → `list_funnel_steps`, `duplicate_funnel_step`, `remove_funnel_step`
- **[Publish blog posts from Markdown](https://cotlet.dev/integrations/systeme-io-api-mcp-server/publish-blog-posts-from-markdown)**: "Publish the three Markdown drafts in /posts to my Systeme.io blog in the Marketing category. Create them all, then activate them after I check." → `list_blog_posts`, `create_blog_post`, `activate_blog_post`

## Can Systeme.io automations run on a schedule in n8n, Make or Zapier?

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

## Tools

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

### list_transactions

Sales from the Transactions page, with customer, offer, amount and transaction type. Access: read. REST: `POST /api/v1/systeme-io/list_transactions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `customer_email` | string | no | Only this customer. |
| `offer` | string | no | Only sales of this offer (name or ID). |
| `type` | string | no | Transaction type, as in the Transactions filter. |
| `from` | date | no | Start of the date range. |
| `to` | date | no | End of the date range. |
| `customer_country` | string | no | Two-letter country code. |
| `customer_type` | enum | no | company or individual. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists transactions with the same filters as the Transactions page: customer email, offer, transaction type, date range, customer country and customer type (company or individual). Results are newest first. Pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "transactions": [
    {
      "transaction_id": "tr_20931",
      "customer_email": "hans@example.com",
      "offer": "Starter course",
      "amount": 97,
      "currency": "EUR",
      "type": "sale",
      "customer_country": "DE",
      "customer_type": "individual",
      "occurred_at": "2026-10-08T09:12:00Z"
    },
    {
      "transaction_id": "tr_20944",
      "customer_email": "office@example.de",
      "offer": "Pro membership",
      "amount": 49,
      "currency": "EUR",
      "type": "sale",
      "customer_country": "DE",
      "customer_type": "company",
      "occurred_at": "2026-10-09T15:40:00Z"
    }
  ],
  "next_cursor": null
}
```

### get_transaction

One sale with customer, offer, amount, payment processor charge ID and refund status. Access: read. REST: `POST /api/v1/systeme-io/get_transaction`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `transaction_id` | string | yes | Transaction ID from list_transactions. |

Returns one transaction as listed on the Transactions page, with the payment processor charge ID and whether it was refunded. Use it before refund_transaction to check the amount and the customer.

Example response:

```json
{
  "transaction_id": "tr_20931",
  "customer_email": "hans@example.com",
  "offer": "Starter course",
  "amount": 97,
  "currency": "EUR",
  "type": "sale",
  "processor_charge_id": "ch_3Q9xExample",
  "refunded": false,
  "occurred_at": "2026-10-08T09:12:00Z"
}
```

### export_transactions

Starts a CSV export of transactions; Systeme.io emails the download link to your account address. Access: read. REST: `POST /api/v1/systeme-io/export_transactions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | date | no | Start of the date range. |
| `to` | date | no | End of the date range. |
| `delimiter` | string | no | Column separator for the CSV file, as offered in the export popup. |

Starts the same CSV export as the Transactions page, for transactions in an optional date range. Systeme.io emails the download link to the address of your account, so the call returns only a confirmation. The export reaches only you.

Example response:

```json
{
  "status": "started",
  "delivery": "email to your account address"
}
```

### list_funnel_steps

Your sales funnels with their steps: name, type, URL path and page ID. Access: read. REST: `POST /api/v1/systeme-io/list_funnel_steps`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `funnel_id` | string | no | Only this funnel. Default: all funnels. |

Lists funnels with their steps in funnel order. Each step has the ID that the page tools take as step_id. Leave funnel_id out to list every funnel.

Example response:

```json
{
  "funnels": [
    {
      "funnel_id": "f_1204",
      "name": "Webinar funnel",
      "steps": [
        {
          "step_id": "8841207",
          "name": "Webinar sales page",
          "type": "sales page",
          "path": "webinar"
        },
        {
          "step_id": "8841219",
          "name": "Thank you",
          "type": "thank you page",
          "path": "webinar-thanks"
        }
      ]
    }
  ]
}
```

### get_page_content

Text elements of a funnel page (headlines, paragraphs, buttons) with an ID per element. Access: read. REST: `POST /api/v1/systeme-io/get_page_content`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `step_id` | string | yes | Funnel step ID from list_funnel_steps. |

Returns the text elements of one funnel page in page order, each with an element ID. Pass those IDs to update_page_text. Images and layout settings are not included.

Example response:

```json
{
  "step_id": "8841207",
  "elements": [
    {
      "element_id": "headline-1a2b",
      "kind": "headline",
      "text": "Free webinar: launch your first course"
    },
    {
      "element_id": "button-9f3c",
      "kind": "button",
      "text": "Register now"
    }
  ]
}
```

### list_blog_posts

Posts of a blog with title, URL path, categories and whether each is active. Access: read. REST: `POST /api/v1/systeme-io/list_blog_posts`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `blog_id` | string | no | Blog to read. Default: your first blog. |
| `limit` | integer | no | 1 to 100. Default: 50. |

Lists the posts of one blog, with the ID that activate_blog_post takes as post_id. The blog_id of your blog is also returned, for create_blog_post. Active posts are visible on the blog; inactive ones are not.

Example response:

```json
{
  "blog_id": "blog_3302",
  "posts": [
    {
      "post_id": "bp_5498",
      "title": "Five launch mistakes",
      "path": "five-launch-mistakes",
      "categories": [
        "Marketing"
      ],
      "active": true
    }
  ],
  "next_cursor": null
}
```

### update_page_text

Change the text of chosen elements on a funnel page and save it; the rest of the page stays as it is. Access: write, asks the user first. REST: `POST /api/v1/systeme-io/update_page_text`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `step_id` | string | yes | Funnel step ID from list_funnel_steps. |
| `changes` | object | yes | Map of element_id from get_page_content to new text. |

Changes the text of the elements you name and saves the page. Other elements, images and settings are not touched. On a live funnel visitors see the change at once. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "step_id": "8841207",
  "updated_elements": 2,
  "saved_at": "2026-10-11T14:05:12+02:00"
}
```

### duplicate_funnel_step

Copy a step below the original, with "(copy)" in its name; set a new URL path for the copy. Access: write. REST: `POST /api/v1/systeme-io/duplicate_funnel_step`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `step_id` | string | yes | Funnel step ID from list_funnel_steps. |
| `path` | string | no | URL path for the copy. |

Duplicates a funnel page and places the copy below the original, named with "(copy)". Pass path to give the copy its own URL. The copy reaches no one until you link to it, and remove_funnel_step undoes it, so this call runs without asking.

Example response:

```json
{
  "step_id": "8841260",
  "name": "Webinar sales page (copy)",
  "path": "webinar-b",
  "copied_from": "8841207"
}
```

### remove_funnel_step

Permanently delete a step and its page from a funnel. Access: write, asks the user first. REST: `POST /api/v1/systeme-io/remove_funnel_step`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `step_id` | string | yes | Funnel step ID from list_funnel_steps. |

Deletes one step and its page from a funnel. This cannot be undone, and visitors lose the page. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "step_id": "8841219",
  "status": "removed"
}
```

### refund_transaction

Refund a sale in full through its payment gateway; an invoice with a negative amount is created. Access: write, asks the user first. REST: `POST /api/v1/systeme-io/refund_transaction`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `transaction_id` | string | yes | Transaction ID from list_transactions. |

Refunds the whole sale; Systeme.io does not support partial refunds. It depends on your payment gateway: the balance must cover the refund. Afterwards the transaction shows an invoice with a negative amount, which send_invoice can email to the customer. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "transaction_id": "tr_20931",
  "status": "refunded",
  "refunded_amount": 97,
  "currency": "EUR"
}
```

### send_invoice

Email the invoice of a transaction to its customer. Access: write, asks the user first. REST: `POST /api/v1/systeme-io/send_invoice`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `transaction_id` | string | yes | Transaction ID from list_transactions. |

Sends the invoice of one transaction to the customer, as the Send invoice to customer action does. After a refund it sends the invoice with the negative amount. Invoices go out one at a time. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "transaction_id": "tr_20931",
  "status": "sent",
  "sent_to": "hans@example.com"
}
```

### create_blog_post

New blog post from Markdown, saved inactive so nobody sees it until you activate it. Access: write. REST: `POST /api/v1/systeme-io/create_blog_post`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `blog_id` | string | yes | Blog ID from list_blog_posts. |
| `title` | string | yes | Post title. |
| `body_markdown` | string | yes | Post content. Images by URL. |
| `description` | string | no | Short description shown on listing pages. |
| `path` | string | no | URL path. Default: made from the title. |
| `categories` | string[] | no | Names of categories that already exist in the blog. |
| `image_url` | string | no | Main image. |

Creates a post with a title, short description, URL path, main image and categories, and fills it with your Markdown. Categories must already exist in the blog. The post is saved inactive, so it reaches no one until activate_blog_post runs; this call runs without asking.

Example response:

```json
{
  "post_id": "bp_5521",
  "blog_id": "blog_3302",
  "title": "How we cut onboarding time in half",
  "categories": [
    "Marketing"
  ],
  "active": false
}
```

### activate_blog_post

Show a post on your blog. Access: write, asks the user first. REST: `POST /api/v1/systeme-io/activate_blog_post`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `post_id` | string | yes | Blog post ID from list_blog_posts. |

Activates one post so visitors can read it on your blog. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "post_id": "bp_5521",
  "active": true
}
```

## How do I connect Systeme.io to Claude Code, Codex or Cursor?

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

### Connect Systeme.io to your agent.

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

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

```
Ana (ana@example.com) wants her money back for the Starter course she bought yesterday. Refund it and email her the refund invoice.
```

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

```
curl https://cotlet.dev/api/v1/systeme-io/update_page_text \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"step_id":"8841207","changes":{"headline-1a2b":"Live training: Thursday 7 PM","button-9f3c":"Save my seat"}}'
```

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

```
{
  "step_id": "8841207",
  "updated_elements": 2,
  "saved_at": "2026-10-11T14:05:12+02:00"
}
```

## Why use Cotlet for Systeme.io?

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

## Is there a Systeme.io MCP server on GitHub?

Systeme.io runs its own MCP server for contacts, newsletters, campaigns, funnels, products and courses; Cotlet adds the sales, page and blog work it leaves out.

|  | Official MCP server | Cotlet |
|---|---|---|
| Setup | Create an MCP key in your profile settings and paste it into your AI client | Request access, sign in to Systeme.io once, add one MCP server or API key |
| When access expires | Keys last 90 days at most; create a new one and paste it again | Your agent gets a link to sign in again |
| Sales and refunds | No transactions, refunds or invoices | Transactions, CSV export, invoices and full refunds, each refund confirmed by you |
| Funnel pages and blog | Creates funnels and regenerates whole pages; no duplicates, deletes or blog posts | Edit page text, duplicate or delete steps, write and activate blog posts |
| Your session | An MCP key with the rights of your account | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When Systeme.io changes | Maintained by Systeme.io | Our team tests it daily and fixes it for you; failed calls are free |
| Price | No separate fee listed in the help center | 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 Systeme.io 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 Systeme.io API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Systeme.io 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 Systeme.io MCP key?**

No. Cotlet works in your own Systeme.io account after you sign in once. Systeme.io's own MCP keys last 90 days at most and you can hold two at a time, so Cotlet does not depend on them.

**Can my agent refund part of a sale?**

No. Systeme.io supports full refunds only, and the payment gateway balance must cover the refund. After it, Systeme.io creates an invoice with a negative amount that send_invoice can email to the customer.

**Can my agent post or send messages in Systeme.io without asking me?**

No. Every call to update_page_text, remove_funnel_step, refund_transaction, send_invoice or activate_blog_post waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. duplicate_funnel_step, create_blog_post runs without asking, because it sends nothing to anyone and one call undoes it.

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