[Cotlet](https://cotlet.dev/index.md) · [Integrations](https://cotlet.dev/integrations.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Use cases](https://cotlet.dev/use-cases.md) · [Security](https://cotlet.dev/security.md) · [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md) · [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [Contact](https://cotlet.dev/contact.md) · [Pricing](https://cotlet.dev/pricing.md) · [Sign up](https://cotlet.dev/signup)

# Sendible API and MCP server

> Sendible documents no public API (checked 20 Oct 2026). The only official automation is a Zapier app with four write actions: create a scheduled post, create a queued post, delete a post and approve a draft post. It has no triggers and reads nothing.

Social media management for agencies and brands: one workspace per client, a calendar, queues, client approvals, a Priority Inbox for comments and messages, and reports.

## What is the Sendible API?

Cotlet's Sendible API exposes 14 endpoints for your own Sendible account: list workspaces, list social profiles, list users, list posts, get a post, list queues, list approval tasks, list Priority Inbox messages, get a Quick Report, create a post, send a post for approval, approve or reject a task, reply to a message and archive inbox messages. The list_workspaces endpoint returns workspaces of your Sendible account: one per client, brand or location. Each endpoint takes simple JSON inputs like workspace_id, from or to and works both as an operation of the sendible_read or sendible_write MCP tool for agents and as a REST call for scripts.

- **Category:** [Marketing & SEO](https://cotlet.dev/integrations/category/marketing-seo.md)
- **Endpoints:** 14 (9 read, 5 write)
- **Updated:** 2026-10-20

Sendible documents no public API (checked 20 Oct 2026). Cotlet is a hosted MCP server and REST API for Sendible with 14 endpoints (9 read, 5 write): you sign in once in your own cloud browser, your AI agent does the work.

## Does Sendible have an official API?

Sendible documents no public API (checked 20 Oct 2026). The only official automation is a Zapier app with four write actions: create a scheduled post, create a queued post, delete a post and approve a draft post. It has no triggers and reads nothing.

| Task | Sendible official | Cotlet |
|---|---|---|
| Create scheduled and queued posts | Partly: Zapier app only: scheduled post and queued post | Yes |
| Approve a draft post | Partly: Zapier app approves a draft by ID; it cannot list tasks or reject | Yes |
| Send a post for approval | No | Yes |
| List posts, drafts and queues | No | Yes |
| Read Priority Inbox messages | No | Yes |
| Reply to comments and messages | No | Yes |
| Read Quick Reports | No | Yes |
| List workspaces, profiles and users | No | Yes |

Sources: [Sendible Help: Automate tasks using Zapier and Sendible](https://support.sendible.com/hc/en-us/articles/29219626674205-Automate-tasks-using-Zapier-and-Sendible), [Zapier: Sendible triggers and actions](https://zapier.com/apps/sendible/integrations), [Sendible Help: Overview of the Priority Inbox](https://support.sendible.com/hc/en-us/articles/208052466-Overview-of-the-Priority-Inbox), [Sendible: Pricing and plan features](https://www.sendible.com/pricing)

## For AI agents

```text
Sendible documents no public API (checked 20 Oct 2026). The only official automation is a Zapier app with four write actions: create a scheduled post, create a queued post, delete a post and approve a draft post. It has no triggers and reads nothing.
Cotlet provides a hosted MCP server and REST API for Sendible: 14 tools (9 read, 5 write).
Access       Sign up at https://cotlet.dev/app/signup?app=sendible, then request the app and create API keys in the Cotlet console.

MCP server   https://cotlet.dev/mcp/v1
MCP tools    sendible_read, sendible_write, reads and writes apart; call one with {"operation": "<operation>", "arguments": {...}}
REST base    https://cotlet.dev/api/v1/sendible, each operation at its own route, e.g. POST /api/v1/sendible/workspaces/{workspace_id}/posts
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one. Over MCP the input schemas come with sign-in.
Operations   list_workspaces, list_profiles, list_users, list_posts, get_post, list_queues, list_tasks, list_inbox_messages, get_report, create_post, send_for_approval, decide_task, reply_to_message, archive_inbox_messages
Confirm      create_post, send_for_approval, decide_task, reply_to_message (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/sendible-api-mcp-server.md

How access works:
1. The user signs up at https://cotlet.dev/app/signup?app=sendible, requests Sendible in the Cotlet console and creates an API key there.
2. The user signs in to Sendible once in their Cotlet Cloud Browser (their own Chrome in the cloud, opened from the console) and enables Sendible for agents. 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 Sendible 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.
Sign-in: the user signs in to Sendible in their own Cloud Browser, a Chrome Cotlet runs for them in the EU; password saving is off, the profile is AES-256-GCM encrypted, and agents get Sendible only after the user enables it. Calls are requests from that browser's IP with its cookies, each listed in the user's Background activity. Disable for agents, signing out in the browser or Reset browser cuts access. Cotlet is run by Take Group sp. z o.o. (EU VAT PL6342984273).
API key: holds no Sendible login or cookies, only asks Cotlet to run a tool. Each key is scoped to chosen apps and tools, read only or read and write. Actions that reach other people wait for the user's approval by default, so a leaked key cannot post or message as the user. Every call is in the activity log; deleting the key ends access at once.
Terms: the user stays responsible for following Sendible's terms; Cotlet is not affiliated with Sendible.
```

## What can an AI agent do in Sendible?

Cotlet is best for agencies and social media managers who run Sendible workspaces for clients and want their AI agent to handle the inbox, approvals, scheduling and weekly reports without running or fixing a server.

- **[Triage the Priority Inbox](https://cotlet.dev/integrations/sendible-api-mcp-server/triage-priority-inbox.md)** (runs: daily): "Read yesterday's Priority Inbox for the Harbor Dental workspace. Reply to questions about opening hours and booking with our standard answer, archive thank-you comments, and list the rest for me with a reason." → `list_workspaces`, `list_inbox_messages`, `reply_to_message`, `archive_inbox_messages`
- **[Weekly client social report](https://cotlet.dev/integrations/sendible-api-mcp-server/weekly-client-report.md)** (runs: weekly): "Every Monday, pull last week's Engagement report for each client workspace and write me three lines per client: audience change, best post and one thing to watch." → `list_workspaces`, `list_profiles`, `get_report`
- **[Chase posts waiting for client approval](https://cotlet.dev/integrations/sendible-api-mcp-server/chase-client-approvals.md)** (runs: daily): "List every post I sent for approval that is still open, oldest first. Flag those already past their publish time, and send the unsent drafts for Harbor Dental to Mia Harbor for approval." → `list_tasks`, `list_posts`, `list_users`, `send_for_approval`
- **Schedule a month of posts from a content plan** (runs: weekly): "Take this month's plan below and schedule each post to the Facebook and Instagram profiles of Harbor Dental at the time I gave. Save any post without a time as a draft." → `list_profiles`, `create_post`, `list_posts`
- **Fill an evergreen queue** (runs: weekly): "Add these 10 tips to the "Weekly tip" queue of Northside Bakery, and tell me how many slots they cover." → `list_queues`, `create_post`
- **Check for failed posts** (runs: daily): "List posts from the last 7 days that failed to publish in any workspace, with the reason, and tell me which ones to resend." → `list_workspaces`, `list_posts`, `get_post`

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

Yes. Cotlet does not replace your automation platform: it gives it a Sendible 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 triage the priority inbox, 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 with the endpoint's method and URL, such as GET https://cotlet.dev/api/v1/sendible/workspaces. | Schedule Trigger node. |
| Make | HTTP module: the endpoint's method and URL with an Authorization: Bearer header, and a JSON body for POST, PUT and PATCH. | Scenario schedule. |
| Zapier | Webhooks by Zapier, Custom Request: the same method, URL, header and body. | Schedule by Zapier trigger. |
| Your own script | GET https://cotlet.dev/api/v1/sendible/workspaces 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 401 without an API key and 403 while the key has no access to Sendible.

### list_workspaces

Workspaces of your Sendible account: one per client, brand or location. Access: read. REST: `GET /api/v1/sendible/workspaces`. MCP: `sendible_read → list_workspaces`.

No parameters.

Returns every workspace you can open, with its time zone, the number of profiles and whether publishing is paused. Sendible keeps one workspace per client, brand or location, and the other tools need a workspace_id from this list. A paused workspace shows its posts as sent although nothing was published.

Example response:

```json
{
  "workspaces": [
    {
      "workspace_id": "ws_4821",
      "name": "Harbor Dental",
      "time_zone": "Europe/London",
      "profiles": 3,
      "publishing_paused": false
    },
    {
      "workspace_id": "ws_4822",
      "name": "Northside Bakery",
      "time_zone": "Europe/London",
      "profiles": 2,
      "publishing_paused": false
    }
  ]
}
```

### list_profiles

Connected social profiles of a workspace, with network and inbox alerts. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/profiles`. MCP: `sendible_read → list_profiles`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `network` | enum | no | facebook, instagram, linkedin, x, tiktok, youtube, google_business, threads, bluesky or wordpress. Default: all. |

Returns the profiles connected to one workspace: id, network, name and whether alerts for the Priority Inbox are on. An Instagram profile is either direct publishing or a reminder profile, which sends the content to your phone or email instead of posting. Connecting a new profile stays in Sendible.

Example response:

```json
{
  "profiles": [
    {
      "profile_id": "pr_301",
      "network": "facebook",
      "name": "Harbor Dental",
      "type": "Facebook Page",
      "inbox_alerts": true
    },
    {
      "profile_id": "pr_302",
      "network": "instagram",
      "name": "harbor.dental",
      "type": "Instagram Professional",
      "inbox_alerts": true
    },
    {
      "profile_id": "pr_303",
      "network": "linkedin",
      "name": "Harbor Dental",
      "type": "LinkedIn Company Page",
      "inbox_alerts": false
    }
  ]
}
```

### list_users

Users of a workspace with their type, so you know who can approve a post. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/users`. MCP: `sendible_read → list_users`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `type` | enum | no | admin, team_member or client. Default: all. |

Returns the users who have access to one workspace: id, name and type. The type is admin, team_member or client, the three user types Sendible has. Use a user_id from here as approver_id in send_for_approval. Adding or editing users stays in Sendible.

Example response:

```json
{
  "users": [
    {
      "user_id": "usr_12",
      "name": "Priya Nair",
      "type": "admin"
    },
    {
      "user_id": "usr_88",
      "name": "Mia Harbor",
      "type": "client"
    }
  ]
}
```

### list_posts

Posts of a workspace calendar, filtered by status, network, profile, queue or dates. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/posts`. MCP: `sendible_read → list_posts`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `status` | enum | no | draft, for_approval, queued, scheduled, sent or failed, the statuses of the Sendible calendar filter. Default: all. |
| `network` | string | no | Only posts for this network, as in list_profiles. |
| `profile_id` | string | no | Only posts for this profile. |
| `queue_id` | string | no | Only posts from this queue. |
| `from` | date | no | First day, YYYY-MM-DD, in the workspace time zone. |
| `to` | date | no | Last day, YYYY-MM-DD. |
| `cursor` | string | no | next_cursor of the previous call. |

Returns posts as the Sendible calendar shows them, soonest first, with status, publish time, profiles, creator and a short text preview. Pass next_cursor back as cursor until it is null. The calendar only holds the previous 12 months, so older posts are not returned. Use get_post for the full text.

Example response:

```json
{
  "posts": [
    {
      "post_id": "post_77a1",
      "status": "for_approval",
      "send_at": "2026-10-23T09:00:00+01:00",
      "profiles": [
        "Harbor Dental (Facebook Page)",
        "Harbor Dental (Instagram)"
      ],
      "created_by": "Priya Nair",
      "preview": "Open this Saturday, 9 to 1. Book at harbordental.example/book"
    },
    {
      "post_id": "post_77b4",
      "status": "draft",
      "send_at": null,
      "profiles": [
        "Harbor Dental (LinkedIn Company Page)"
      ],
      "created_by": "Priya Nair",
      "preview": "Three signs it is time to book a check-up"
    }
  ],
  "next_cursor": null
}
```

### get_post

Full text, media, profiles, status and approval state of one post. Access: read. REST: `GET /api/v1/sendible/posts/{post_id}`. MCP: `sendible_read → get_post`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `post_id` | string | yes | Post from list_posts. |

Returns one post with its complete text, link, media URL, profiles, publish time, status and creator. A post in approval also shows the approver. A failed post shows the error text Sendible gives for it. The post is not changed.

Example response:

```json
{
  "post_id": "post_77a1",
  "status": "for_approval",
  "send_at": "2026-10-23T09:00:00+01:00",
  "message": "Open this Saturday, 9 to 1. Book at harbordental.example/book",
  "url": "https://harbordental.example/book",
  "media_url": null,
  "profiles": [
    "Harbor Dental (Facebook Page)",
    "Harbor Dental (Instagram)"
  ],
  "created_by": "Priya Nair",
  "approver": "Mia Harbor",
  "error": null
}
```

### list_queues

Queues of a workspace with their weekly time slots and how many posts wait in each. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/queues`. MCP: `sendible_read → list_queues`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |

Returns the queues from Publish > Queues: name, whether posts are recycled to the bottom after sending, the day and time slots and the number of posts waiting. A queue sends one post per slot, to one or more profiles. Creating or editing a queue stays in Sendible.

Example response:

```json
{
  "queues": [
    {
      "queue_id": "q_19",
      "name": "Weekly tip",
      "recycle": true,
      "slots": [
        "Mon 09:00",
        "Thu 09:00"
      ],
      "posts_waiting": 12
    },
    {
      "queue_id": "q_20",
      "name": "Offers",
      "recycle": false,
      "slots": [
        "Fri 12:00"
      ],
      "posts_waiting": 3
    }
  ]
}
```

### list_tasks

Tasks from Publish > Tasks: posts waiting for approval and assigned messages. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/tasks`. MCP: `sendible_read → list_tasks`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `view` | enum | no | for_me, for_others or done. Default: for_me. |
| `from` | date | no | Only tasks on or after this day, YYYY-MM-DD. |
| `to` | date | no | Only tasks on or before this day. |

Returns tasks newest first. view for_me are tasks others sent you, for_others are tasks you sent, done are tasks marked as done. Each task keeps Sendible's own label: "Scheduled for" while the publish time is ahead, "Received on" once it has passed. Approving a "Received on" task sends the post immediately.

Example response:

```json
{
  "tasks": [
    {
      "task_id": "task_5502",
      "post_id": "post_77a1",
      "assigned_to": "Mia Harbor",
      "sent_by": "Priya Nair",
      "label": "Scheduled for",
      "send_at": "2026-10-23T09:00:00+01:00",
      "comment": "Please approve by Thursday 17:00. It goes out Friday at 09:00."
    },
    {
      "task_id": "task_5497",
      "post_id": "post_76f0",
      "assigned_to": "Mia Harbor",
      "sent_by": "Priya Nair",
      "label": "Received on",
      "send_at": "2026-10-19T09:00:00+01:00",
      "comment": ""
    }
  ]
}
```

### list_inbox_messages

Comments and messages from Activity > Priority Inbox, with sentiment. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/inbox-messages`. MCP: `sendible_read → list_inbox_messages`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `profile_id` | string | no | Only messages for this profile. |
| `from` | date | no | Only messages on or after this day, YYYY-MM-DD. |
| `to` | date | no | Only messages on or before this day. |
| `search` | string | no | Words to find in the message body. |
| `archived_only` | boolean | no | Show the Archived Only view. Default: false. |

Returns inbox messages for profiles with alerts on: Facebook Page comments, replies and direct messages, Facebook Ads comments, Instagram Professional comments, LinkedIn Company Page replies and YouTube comments. Each has type public_comment or private_message and a sentiment of positive, neutral or negative, which Sendible scores from good and bad words. Messages arrive 1 to 2 hours late and only for recent posts. X, TikTok, Google Business and Instagram direct messages never appear.

Example response:

```json
{
  "messages": [
    {
      "message_id": "msg_91f2",
      "profile": "Harbor Dental (Facebook Page)",
      "type": "public_comment",
      "author": "Dana Cole",
      "text": "Do you open on Saturdays?",
      "sentiment": "neutral",
      "received_at": "2026-10-20T06:42:00+01:00",
      "hours_waiting": 3,
      "archived": false
    },
    {
      "message_id": "msg_91f9",
      "profile": "Harbor Dental (Instagram)",
      "type": "public_comment",
      "author": "Ben Ortiz",
      "text": "Love the new waiting room",
      "sentiment": "positive",
      "received_at": "2026-10-20T02:10:00+01:00",
      "hours_waiting": 7,
      "archived": false
    }
  ]
}
```

### get_report

A Quick Report from Reports > All Reports for a date range: engagement or one network. Access: read. REST: `GET /api/v1/sendible/workspaces/{workspace_id}/report`. MCP: `sendible_read → get_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `report` | string | yes | engagement, or a network name such as facebook. |
| `profile_ids` | array | yes | Profiles to include, from list_profiles. Network reports take 1 to 10. |
| `from` | date | yes | First day, YYYY-MM-DD. Not older than 90 days. |
| `to` | date | yes | Last day, YYYY-MM-DD, before today. |

Returns the figures of a standard Quick Report, such as audience growth per profile, engaged users and top content. report engagement covers Facebook, Instagram and LinkedIn Company Page profiles, up to 50. A network report takes 1 to 10 profiles of that network, and Quick Reports exist for several, not all, networks. The range cannot include today, and Sendible keeps 90 days of data.

Example response:

```json
{
  "report": "engagement",
  "from": "2026-10-12",
  "to": "2026-10-18",
  "profiles": [
    {
      "profile_id": "pr_301",
      "name": "Harbor Dental (Facebook Page)",
      "followers_start": 2140,
      "followers_end": 2162,
      "change": 22,
      "engaged_users": 96
    },
    {
      "profile_id": "pr_302",
      "name": "Harbor Dental (Instagram)",
      "followers_start": 1310,
      "followers_end": 1331,
      "change": 21,
      "engaged_users": 71
    },
    {
      "profile_id": "pr_303",
      "name": "Harbor Dental (LinkedIn Company Page)",
      "followers_start": 402,
      "followers_end": 404,
      "change": 2,
      "engaged_users": 21
    }
  ],
  "totals": {
    "change": 45,
    "engaged_users": 188
  },
  "top_content": [
    {
      "profile": "Harbor Dental (Instagram)",
      "text": "Smile Monday: free whitening tray",
      "engagements": 64
    }
  ]
}
```

### create_post

Schedule a post, add it to a queue or save it as a draft, for one or more profiles. Access: write, asks the user first. REST: `POST /api/v1/sendible/workspaces/{workspace_id}/posts`. MCP: `sendible_write → create_post`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `workspace_id` | string | yes | Workspace from list_workspaces. |
| `profile_ids` | array | yes | Profiles from list_profiles. Optional for a draft. |
| `message` | string | yes | Post text. |
| `url` | string | no | Link to add to the post. |
| `image_url` | string | no | One image, as a public URL. |
| `mode` | enum | yes | schedule, queue or draft. |
| `send_at` | datetime | no | Publish time, local to the workspace, e.g. 2026-10-23T09:00:00. Required for schedule. |
| `queue_id` | string | no | Queue from list_queues. Required for queue. |

mode schedule publishes at send_at in the workspace time zone, queue adds the post to the queue's next free slot, and draft saves it in Publish > Drafts without a time. The post takes text, one link and one image URL; nothing is uploaded. Sendible limits published posts per day per workspace: 20 on a trial, 100 on Core, 200 on Plus, 300 on Premium, 500 on Elite and Enterprise. A draft reaches no one, but the same tool schedules real posts, so every call asks. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "post_id": "post_77a1",
  "status": "scheduled",
  "send_at": "2026-10-23T09:00:00+01:00",
  "time_zone": "Europe/London",
  "profiles": [
    "Harbor Dental (Facebook Page)",
    "Harbor Dental (Instagram)"
  ]
}
```

### send_for_approval

Send a post to a user for approval, with a comment. Access: write, asks the user first. REST: `POST /api/v1/sendible/posts/{post_id}/approvals`. MCP: `sendible_write → send_for_approval`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `post_id` | string | yes | Post from list_posts. |
| `approver_id` | string | yes | User from list_users. |
| `comment` | string | no | Note shown to the approver. |

Moves a scheduled post or a draft into approval and creates a task for the approver. The approver gets a notification on their dashboard and an email, and you are notified when they approve or reject. Sendible says approval workflows are not available on all plans. The post is published only after approval. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "post_id": "post_77a1",
  "task_id": "task_5502",
  "status": "for_approval",
  "approver": "Mia Harbor",
  "send_at": "2026-10-23T09:00:00+01:00"
}
```

### decide_task

Approve and send a post, or reject it with a comment. Access: write, asks the user first. REST: `POST /api/v1/sendible/tasks/{task_id}/decide`. MCP: `sendible_write → decide_task`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `task_id` | string | yes | Task from list_tasks, view for_me. |
| `decision` | enum | yes | approve or reject. |
| `comment` | string | no | Note for the sender. Shown with a reject. |

approve is Sendible's Approve & Send: the post goes out as scheduled, or at once if its publish time has passed ("Received on" in list_tasks). reject returns the post to the sender's task list with your comment followed by "[Rejected]". Marking a task as done is not approval and is not offered here. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "task_id": "task_5502",
  "post_id": "post_77a1",
  "decision": "approve",
  "status": "scheduled",
  "send_at": "2026-10-23T09:00:00+01:00"
}
```

### reply_to_message

Reply to a comment or message in the Priority Inbox. Access: write, asks the user first. REST: `POST /api/v1/sendible/messages/{message_id}/replies`. MCP: `sendible_write → reply_to_message`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `message_id` | string | yes | Message from list_inbox_messages. |
| `body` | string | yes | Reply text. |

Sends a reply as the profile the message came in on. It works for Facebook, Instagram and LinkedIn, the networks Sendible lets you reply on from the Priority Inbox. A Facebook private message can be answered only within 24 hours after it was sent. The reply is public for a comment and private for a message. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "message_id": "msg_91f2",
  "reply_id": "rep_5c10",
  "status": "sent",
  "profile": "Harbor Dental (Facebook Page)"
}
```

### archive_inbox_messages

Move messages out of the Priority Inbox into Archived Only, or restore them. Access: write. REST: `POST /api/v1/sendible/inbox-messages/archive`. MCP: `sendible_write → archive_inbox_messages`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `message_ids` | array | yes | Messages from list_inbox_messages. |
| `restore` | boolean | no | Restore from Archived Only instead of archiving. Default: false. |

Archives the given messages, or restores them when restore is true. Archived messages stay in the Archived Only view and nothing is deleted. It reaches no one and is undone with one call, so it does not ask for your OK.

Example response:

```json
{
  "archived": [
    "msg_91f9"
  ],
  "restored": [],
  "failed": []
}
```

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

Connecting Sendible takes three steps: sign up, sign in to Sendible once in your Cloud Browser and enable it for agents, then add one MCP server or call the REST API with the same key.

### Connect Sendible to your agent.

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

2. **Sign in to Sendible in your Cloud Browser** Open your Cloud Browser in the console: your own Chrome in the cloud. Sign in to Sendible there yourself, the way you always do, then press Enable for agents, read only or read and write. We never save your password, and your agent keeps working even when your computer is off.

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 Sendible 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.

```
Read yesterday's Priority Inbox for the Harbor Dental workspace. Reply to questions about opening hours and booking with our standard answer, archive thank-you comments, and list the rest for me with a reason.
```

### Call Sendible 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 an endpoint under /api/v1/sendible with its own method and path, listed with the endpoints above. Path parameters go in the URL; the other parameters go in the query for GET and DELETE and in a JSON body otherwise.

```
curl -X POST https://cotlet.dev/api/v1/sendible/workspaces/ws_4821/posts \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"profile_ids":["pr_301","pr_302"],"message":"Open this Saturday, 9 to 1. Book at harbordental.example/book","url":"https://harbordental.example/book","mode":"schedule","send_at":"2026-10-23T09:00:00"}'
```

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

```
{
  "post_id": "post_77a1",
  "status": "scheduled",
  "send_at": "2026-10-23T09:00:00+01:00",
  "time_zone": "Europe/London",
  "profiles": [
    "Harbor Dental (Facebook Page)",
    "Harbor Dental (Instagram)"
  ]
}
```

## Why use Cotlet for Sendible?

**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 Sendible yourself, in your own Cloud Browser. We never save your password; the profile is encrypted with AES-256-GCM, the cipher 1Password uses.
- A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory.
- The model never sees a login.
- No stored passwords, no CAPTCHA solving, no MFA bypass.

**You stay in control**

- Scope each API key: its apps, its tools, read only or read and write.
- Anything that reaches other people waits for your OK, so a leaked key cannot post or message as you.
- Every background request listed in your Background activity. Disable for agents in one click.

**Kept working for you**

- We test every integration every 6 hours.
- When Sendible changes, the tool pauses until we fix it.
- Failed calls cost nothing.

## Is it safe to connect Sendible to Cotlet?

Yes. You sign in to Sendible yourself, in your own Cloud Browser, and we never save your password. Your agents only get Sendible once you enable it, and every background request is listed. The browser profile is stored encrypted with AES-256-GCM, the same cipher 1Password uses for its vaults and Apple for iCloud Keychain. Independent public scanners grade cotlet.dev A+ and find it clean; click a result to rerun it yourself.

- **A+ on Qualys SSL Labs**: Encryption in transit: TLS setup and certificates, on all four server addresses. [Live result](https://www.ssllabs.com/ssltest/analyze.html?d=cotlet.dev)
- **A+ on securityheaders.com**: Browser protections sent with every page, all six headers present. [Live result](https://securityheaders.com/?q=cotlet.dev&followRedirects=on)
- **A+ on Mozilla Observatory**: Mozilla's web security baseline: score 120 of 100, 12 of 12 tests passed. [Live result](https://developer.mozilla.org/en-US/observatory/analyze?host=cotlet.dev)
- **Clean on Sucuri SiteCheck**: No malware, spam or defacement, and not on any of 9 blocklists, Google Safe Browsing included. [Live result](https://sitecheck.sucuri.net/results/cotlet.dev)

[How Cotlet protects your access](https://cotlet.dev/security.md)

### Common concerns

**Who runs Cotlet?**

Cotlet is run by Take Group, a Polish software company working since 2019. Take Group runs about 3,200 websites on its own systems and has its own DevOps team for infrastructure security. We built and used integrations like this inside the company for years before opening them as Cotlet.

**Is this an official Sendible integration?**

No, Cotlet is independent of Sendible. Sendible's own API is too limited for this work. Cotlet works through your own Sendible account, the way you use Sendible in the browser, so you need no partner approval and no developer setup.

**What about client data and GDPR?**

Cotlet is run from the EU and follows the GDPR. Cloud Browsers run in Finland, a Tier 1 country in the ITU Global Cybersecurity Index 2024. Data passes through a call and is not kept after it.

**Can I start with read only?**

Yes. Enable the app for agents as read only, or make the API key read only, and anything that reaches other people waits for your OK unless you switch that off per tool.

**Is it reliable?**

Every Cotlet service is checked every 3 minutes from Europe, North America, Asia and Australia. The live results and any outage are public at status.cotlet.dev.

**How do I stop?**

Press Disable for agents next to Sendible in your console: your agents lose access at once and you stay signed in. Signing out of Sendible in the browser works too, and Reset browser deletes the whole profile.

## Is there a Sendible MCP server on GitHub?

The realistic option is Zapier. Sendible's own Zapier app creates scheduled and queued posts, deletes a post and approves a draft, and Zapier can offer those actions to an AI agent. It cannot read posts, the inbox or reports, and it cannot reply. Cotlet reads and writes in your workspace, and you can use both: Zapier for triggers from other apps, Cotlet for the rest.

|  | Zapier | Cotlet |
|---|---|---|
| Setup | Connect Sendible to Zapier and build one Zap per job | Sign up, sign in to Sendible once, add one MCP server or API key |
| What it does | Create scheduled and queued posts, delete a post, approve a draft | Also reads posts, the inbox and reports, replies, sends posts for approval |
| When Sendible changes | Zapier maintains its Sendible app | Our team tests it daily and fixes it for you; failed calls are free |
| Your Sendible session | You authorise Zapier in your Sendible workspace | In your own Cloud Browser in the EU, profile encrypted, only for the apps you enable, disabled for agents in one click |
| Upkeep | You build, test and monitor each Zap | Nothing to host or update |
| Where it runs | Zapier, started by a trigger in another app | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | A Zapier account on top of your Sendible plan | Free 7-day trial, then pay-as-you-go credit packs, no subscription |

### 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 Sendible 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 your sign-in to stay on your own computer
- you only need it now and then, from one MCP client

## How much does the Sendible API cost?

Free 7-day trial with 2,000 credits, no card needed. After that, the Sendible API is pay as you go with no limit on apps: Credit packs from $29 for 5,000 credits, one-time, no subscription. A successful call uses 20 to 30 credits (25 for most tools, about $0.10 to $0.15), your Cloud Browser uses 50 credits a day while it has an app enabled for agents, however many apps that is, and an agent driving the browser itself uses 5 credits a minute. Credit packs stay valid for 12 months and stack, so unused credits carry over.

| Credits | Price, one time | Calls at 25 credits | Per 1,000 credits |
|---|---|---|---|
| 5,000 | $29 | 200 | $5.80 |
| 15,000 | $79 | 600 | $5.27 |
| 32,000 | $149 | 1,280 | $4.66 |
| 60,000 | $249 | 2,400 | $4.15 |

Only successful calls use credits; failed calls and timeouts cost nothing. At a balance of 0 calls pause, never a surprise charge. Authenticate with the `Authorization: Bearer` header. [See full pricing](https://cotlet.dev/pricing.md)

## How Cotlet holds your access

Cotlet hosts MCP servers and REST APIs for apps with no usable API. Your agent works in your own Sendible account.

- **Company details:** Cotlet is run by Take Group sp. z o.o., a company registered in Poland. Its full address and registration numbers are in the Terms of service. [Terms of service](https://cotlet.dev/terms)
- **Your sign-in:** You sign in to Sendible yourself, in your own Cloud Browser: a Chrome we run for you in the EU, one per app. We never save your password (password saving is off), the profile is stored encrypted with AES-256-GCM, and your agents get Sendible only after you enable it. When Sendible signs you out, your agent gives you a link to sign in again. [Security](https://cotlet.dev/security.md)
- **Revoking access:** Press Disable for agents next to Sendible, sign out of Sendible in your Cloud Browser, or reset the browser. Every background request is listed in your Background activity. 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.
- **Sendible's terms:** You use your own Sendible account and stay responsible for following Sendible's terms. Cotlet is independent and not affiliated with Sendible. [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?**

Sign up free, open Sendible in the console and press Request access. Then you create your API key and connect Sendible there.

**Do I need to be technical?**

No. You sign in to Sendible once in your Cloud Browser, a normal Chrome you open from the console, 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 it safe to connect Sendible to Cotlet?**

Yes. You sign in to Sendible yourself, in your own Cloud Browser in the EU, and we never save your password. Your agents only get Sendible once you enable it, every background request is listed, and the browser profile is stored encrypted with AES-256-GCM, the cipher 1Password uses for its vaults. The AI model never sees a login, posts and messages wait for your OK, and Disable for agents cuts access in one click. Independent scanners grade cotlet.dev A+ on Qualys SSL Labs, securityheaders.com and Mozilla Observatory; live results are on https://cotlet.dev/security.

**Is a hosted server safer than a local one? My Sendible sign-in would leave my computer.**

On Cotlet you sign in inside your own Cloud Browser, which only you open, and its profile is stored encrypted with AES-256-GCM in the EU. Agents get only the apps you enable, and every background request is listed. A local server keeps your Sendible cookie in a plain file on your computer, readable by any program you run, and stops when your computer is off.

**Why does Cotlet send requests instead of clicking in my browser?**

To be fast, Cotlet doesn't click through Sendible's pages. It sends the same requests your browser would, from your browser's IP with its cookies, without opening a window. Sendible sees the same browser and IP you signed in with, and every request is listed in your Background activity.

**What if someone gets my Cotlet API key?**

The key holds no Sendible login or cookies, it only asks Cotlet to run a tool. It can call only the apps and tools you gave it, and a read-only key changes nothing. Anything that reaches other people, like posts, comments or messages, waits for your OK in the dashboard by default, so a leaked key cannot post or message as you. When you switch approval off for a scheduled job, give that job its own key limited to that one tool. Every call is in your activity log, and deleting the key ends access at once.

**Why a signed-in browser and not OAuth, like other integration platforms?**

Sendible offers no OAuth token you can simply grant for these tools: its official API leaves them out or needs a developer app, a plan or an approval first (see the official API section above). That is why Cotlet sets the limits itself: per key, per tool, with your approval before anything reaches other people. Cotlet is run by Take Group sp. z o.o., an EU company (VAT PL6342984273).

**Which Sendible plan do I need?**

Cotlet works inside your own Sendible account, so it needs no API plan. The features of your plan still apply: Sendible says approval workflows and editing a saved report are not on all plans. The daily posting limit also stays: 20 posts per workspace on a trial, then 100 on Core, 200 on Plus, 300 on Premium and 500 on Elite and Enterprise (Sendible Help: Account sending limits).

**Which inbox messages can my agent read and answer?**

Those in Sendible's Priority Inbox: Facebook Page comments, replies and direct messages, Facebook Ads comments, Instagram Professional comments, LinkedIn Company Page replies and YouTube comments. X, TikTok, Google Business, personal LinkedIn profiles and Instagram direct messages are not in it. Replies work for Facebook, Instagram and LinkedIn (Sendible Help: Overview of the Priority Inbox, Reply to a message).

**What can it not do?**

create_post takes text, one link and one image URL; it does not upload files or video. Nothing deletes a published post: Sendible itself allows that only for Facebook posts in the Social feeds view (Sendible Help: Can I delete posts on my social accounts). Billing, users, permissions and connecting social accounts stay in Sendible.

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

No. Every call to create_post, send_for_approval, decide_task or reply_to_message waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. archive_inbox_messages runs without asking, because it sends nothing to anyone and one call undoes it.

**Can I use the Sendible API in n8n?**

Yes. Add https://cotlet.dev/mcp/v1 with your API key in n8n's MCP Client node, or call its endpoints under https://cotlet.dev/api/v1/sendible from the HTTP Request node.

---

Give your AI agents your signed-in browser.

**Product:** [Integrations](https://cotlet.dev/integrations.md) · [Use cases](https://cotlet.dev/use-cases.md) · [How it works](https://cotlet.dev/how-it-works.md) · [Pricing](https://cotlet.dev/pricing.md) · [Security](https://cotlet.dev/security.md)

**Resources:** [Blog](https://cotlet.dev/blog.md) · [API docs](https://cotlet.dev/docs.md) · [Help center](https://cotlet.dev/help.md) · [Changelog](https://cotlet.dev/changelog.md) · [GitHub](https://github.com/cotletdev/cotlet)

**Solutions:** [For developers](https://cotlet.dev/for-developers.md) · [For automation agencies](https://cotlet.dev/for-agencies.md)

**Company:** [About](https://cotlet.dev/about.md) · [AI info: company facts](https://cotlet.dev/ai-info.md) · [Contact](https://cotlet.dev/contact.md)

**Legal:** [Terms of service](https://cotlet.dev/terms) · [Privacy policy](https://cotlet.dev/privacy) · [Refund policy](https://cotlet.dev/refunds) · [Acceptable use](https://cotlet.dev/acceptable-use) · [Cookie policy](https://cotlet.dev/cookies) · [DPA](https://cotlet.dev/dpa) · [Subprocessors](https://cotlet.dev/subprocessors)

**Elsewhere:** [Status page](https://status.cotlet.dev) · [Cotlet on GitHub](https://github.com/cotletdev) · [Cotlet on X](https://x.com/cotletdev) · [Cotlet on LinkedIn](https://www.linkedin.com/company/cotletdev) · [Cotlet on Product Hunt](https://www.producthunt.com/products/cotlet) · [Cotlet on Crunchbase](https://www.crunchbase.com/organization/cotlet) · [Cotlet on SaaSHub](https://www.saashub.com/cotlet)

Cotlet is an independent service. It is not affiliated with, endorsed by or sponsored by any of the products listed on this site. Product names are trademarks of their respective owners.

## For AI agents: sign your user up

Is your user asking you to sign them up for Cotlet? You can do it for them, no account or key needed.

1. Read the fields and their allowed values: GET https://cotlet.dev/api/v1/access-requests
2. Ask the user for each value: email, apps, what you will do with them. If they leave the password to you, generate a strong one and show it to them.
3. Show the user what you will send, then POST it as JSON to https://cotlet.dev/api/v1/access-requests.

One call creates the account and sends the access request; we email the user when access is granted.