# Riverside API and MCP server

> Riverside has a Business API for select Business accounts only, with a key from your customer success manager, and it mostly gets or deletes recordings and lists scheduled events (checked 11 Oct 2026). Its official MCP server (beta, Grow, Webinar and Business plans) searches, edits and posts clips, but cannot schedule sessions or invite guests.

Remote recording studio for podcasts and video: every guest is recorded locally as a separate track, with transcripts, an editor and a Planner for scheduled sessions.

## What is the Riverside API?

Cotlet's Riverside API exposes 12 endpoints for your own Riverside account: list studios, list sessions, get invite links, list recordings, get recording, get transcript, download tracks, create studio, schedule session, update session, invite guest and cancel session. The list_studios endpoint returns your studios with name, recording type and the studio link. Each endpoint takes simple JSON inputs like studio_id, recording_id or name and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Creators & communities](https://cotlet.dev/integrations/category/creators-communities)
- **Endpoints:** 12 (7 read, 5 write)
- **Updated:** 2026-10-11

Riverside has a Business API for select Business accounts only, with a key from your customer success manager, and it mostly gets or deletes recordings and lists scheduled events (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Riverside with 12 endpoints (7 read, 5 write): your AI agent signs in as you and does the work.

## Does Riverside have an official API?

Riverside has a Business API for select Business accounts only, with a key from your customer success manager, and it mostly gets or deletes recordings and lists scheduled events (checked 11 Oct 2026). Its official MCP server (beta, Grow, Webinar and Business plans) searches, edits and posts clips, but cannot schedule sessions or invite guests.

| Task | Riverside official | Cotlet |
|---|---|---|
| Schedule a recording session | No | Yes |
| Reschedule or cancel a session | No | Yes |
| Invite guests or producers by email | No | Yes |
| Create a studio | No | Yes |
| List scheduled sessions | Partly: Business API only, read-only | Yes |
| List studios and recordings | Partly: Riverside MCP, Grow plan and up | Yes |
| Read transcripts | Partly: Riverside MCP, Grow plan and up | Yes |
| Download recordings | Partly: Business API (select accounts) and MCP download links; separate tracks are not listed | Yes |

Sources: [Riverside Business API docs](https://docs.riverside.fm/quickstart), [Riverside Help: Connect to Riverside MCP](https://support.riverside.com/hc/en-us/articles/37803607978141-Connect-to-Riverside-MCP), [Riverside MCP plugin README (Riverside, GitHub)](https://github.com/riversidefm/riverside-mcp-public/blob/main/README.md), [Riverside Help: Schedule a studio session](https://support.riverside.com/hc/en-us/articles/5288149163037-Schedule-a-studio-session)

## For AI agents

```text
Riverside has a Business API for select Business accounts only, with a key from your customer success manager, and it mostly gets or deletes recordings and lists scheduled events (checked 11 Oct 2026). Its official MCP server (beta, Grow, Webinar and Business plans) searches, edits and posts clips, but cannot schedule sessions or invite guests.
Cotlet provides a hosted MCP server and REST API for Riverside: 12 tools (7 read, 5 write).
Access       Request access at https://cotlet.dev/app/signup?app=riverside; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/riverside
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_studios, list_sessions, get_invite_links, list_recordings, get_recording, get_transcript, download_tracks, create_studio, schedule_session, update_session, invite_guest, cancel_session
Confirm      create_studio, schedule_session, update_session, invite_guest, cancel_session (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/riverside-api-mcp-server.md

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

## What can an AI agent do in Riverside?

Cotlet is best for podcasters and producers who book guests and hand off recordings every week and want their AI agent to do it without running or fixing a server.

- **[Schedule a podcast recording and invite the guest](https://cotlet.dev/integrations/riverside-api-mcp-server/schedule-recording-session)** (runs: weekly): "Book a recording in my Product Hour studio with guest@example.com next Thursday at 15:00 London time, one hour, called "Episode 42: Pricing your first product", and send the invite. Check the studio is free first." → `list_studios`, `list_sessions`, `schedule_session`
- **[Reschedule or cancel a recording session](https://cotlet.dev/integrations/riverside-api-mcp-server/reschedule-recording-session)**: "My guest for Thursday's recording can't make it. Move the session to Friday at 11:00 London time and make sure they get the new time. If Friday is taken, cancel it and tell me who to email." → `list_sessions`, `update_session`, `invite_guest`, `cancel_session`
- **[Download separate tracks for your editor](https://cotlet.dev/integrations/riverside-api-mcp-server/download-separate-tracks)** (runs: weekly): "Get the raw WAV of each participant from yesterday's episode in The Product Hour for my editor. If anyone's track is still uploading, tell me who, and don't send partial files." → `list_recordings`, `get_recording`, `download_tracks`
- **Turn a transcript into show notes**: "Take the transcript of my last interview and write show notes with timestamps and three pull quotes." → `list_recordings`, `get_transcript`
- **Weekly list of upcoming recording sessions** (runs: weekly): "Every Monday, list the sessions I have scheduled this week and who is invited to each." → `list_sessions`

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

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

## Tools

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

### list_studios

Your studios with name, recording type and the studio link. Access: read. REST: `POST /api/v1/riverside/list_studios`.

No parameters.

Returns every studio in your account, the ones you own and the ones you were added to. Use studio_id from each item in the other calls. Recording type is audio and video or audio only, as set in the studio.

Example response:

```json
{
  "studios": [
    {
      "studio_id": "std_8f2k41",
      "name": "The Product Hour",
      "recording_type": "audio_video",
      "studio_url": "https://riverside.com/studio/the-product-hour"
    },
    {
      "studio_id": "std_2m9c07",
      "name": "Founders Q&A",
      "recording_type": "audio_only",
      "studio_url": "https://riverside.com/studio/founders-qa"
    }
  ]
}
```

### list_sessions

Sessions from the studio Planner, with time, time zone and invited people. Access: read. REST: `POST /api/v1/riverside/list_sessions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `studio_id` | string | no | Only this studio. Default: all studios. |
| `from` | date | no | Sessions on or after this date. Default: today. |
| `to` | date | no | Sessions on or before this date. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists scheduled sessions in start order, soonest first. Each item has the invited guests, producers and audience members with their roles. Pass session_id to update_session, invite_guest or cancel_session.

Example response:

```json
{
  "sessions": [
    {
      "session_id": "ses_3vq9x7",
      "studio_id": "std_8f2k41",
      "name": "Episode 42: Pricing your first product",
      "start": "2026-10-15T15:00:00+01:00",
      "end": "2026-10-15T16:00:00+01:00",
      "invited": [
        {
          "email": "guest@example.com",
          "role": "guest"
        }
      ]
    }
  ],
  "next_cursor": null
}
```

### get_invite_links

The studio links to share with a guest, a producer or an audience. Access: read. REST: `POST /api/v1/riverside/get_invite_links`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `studio_id` | string | yes | Studio ID from list_studios. |

Returns the studio link for each role. Guest and producer links let people join the studio; the audience link works only while audience public access is turned on in the studio. A link you share yourself does not expire, unlike the link in an invite email.

Example response:

```json
{
  "studio_id": "std_8f2k41",
  "links": {
    "guest": "https://riverside.com/studio/the-product-hour?t=guest-token",
    "producer": "https://riverside.com/studio/the-product-hour?t=producer-token",
    "audience": null
  }
}
```

### list_recordings

Recordings in your projects, newest first, with duration, participants and upload status. Access: read. REST: `POST /api/v1/riverside/list_recordings`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `studio_id` | string | no | Only this studio. Default: all studios. |
| `since` | date | no | Only recordings made on or after this date. |
| `limit` | integer | no | 1 to 50. Default: 20. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists recordings across your studios, newest first. Filter by studio or by date to find the latest episode. Upload status shows whether each participant's files are fully uploaded. Pass recording_id to get_recording, get_transcript and download_tracks.

Example response:

```json
{
  "recordings": [
    {
      "recording_id": "rec_71d3ab",
      "studio_id": "std_8f2k41",
      "title": "Episode 41: Launch week",
      "recorded_at": "2026-10-08T15:02:00+01:00",
      "duration_seconds": 3412,
      "participants": [
        "Host",
        "Guest"
      ],
      "upload_status": "complete"
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjIwfQ"
}
```

### get_recording

One recording with its date, duration and each participant's tracks, with type and upload status. Access: read. REST: `POST /api/v1/riverside/get_recording`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `recording_id` | string | yes | Recording ID from list_recordings. |

Returns one recording and the tracks of each participant. Each track has a type (audio or video, and screen share when one was recorded) and an upload status. Read it before download_tracks to see whether every track has finished uploading.

Example response:

```json
{
  "recording_id": "rec_71d3ab",
  "title": "Episode 41: Launch week",
  "duration_seconds": 3412,
  "participants": [
    {
      "name": "Host",
      "tracks": [
        {
          "type": "audio",
          "upload_status": "complete"
        },
        {
          "type": "video",
          "upload_status": "complete"
        }
      ]
    },
    {
      "name": "Guest",
      "tracks": [
        {
          "type": "audio",
          "upload_status": "complete"
        },
        {
          "type": "video",
          "upload_status": "uploading"
        }
      ]
    }
  ]
}
```

### get_transcript

The transcript of a recording with speaker names and timestamps. Access: read. REST: `POST /api/v1/riverside/get_transcript`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `recording_id` | string | yes | Recording ID from list_recordings. |
| `format` | enum | no | txt or srt. Default: txt. |

Returns the transcript Riverside made for one recording, in speaker order with timestamps. Use format srt for subtitle files and txt for plain reading. The call fails if the recording has no transcript yet.

Example response:

```json
{
  "recording_id": "rec_71d3ab",
  "format": "txt",
  "text": "[00:00:04] Host: Welcome back to The Product Hour.\n[00:00:09] Guest: Thanks for having me."
}
```

### download_tracks

Download links for the separate track of each participant in a recording. Access: read. REST: `POST /api/v1/riverside/download_tracks`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `recording_id` | string | yes | Recording ID from list_recordings. |
| `file_type` | enum | no | raw_video, aligned_video, raw_audio or compressed_audio, as named in the Riverside Download menu. Default: raw_audio. |
| `participants` | string[] | no | Only these participant names. Default: everyone. |

Returns one download link per participant for the file type you choose: raw video, aligned video, raw audio or compressed audio, the options in the Riverside Download menu. Tracks that are still uploading are listed without a link. Screen share tracks in high quality exist only when the screen share was recorded with the Mac app. Edited tracks are not included; they come from an edit export.

Example response:

```json
{
  "recording_id": "rec_71d3ab",
  "file_type": "raw_audio",
  "files": [
    {
      "participant": "Host",
      "url": "https://downloads.example.com/rec_71d3ab/host.wav",
      "status": "ready"
    },
    {
      "participant": "Guest",
      "url": "https://downloads.example.com/rec_71d3ab/guest.wav",
      "status": "ready"
    }
  ]
}
```

### create_studio

Create a new studio for a show. Access: write, asks the user first. REST: `POST /api/v1/riverside/create_studio`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Studio name, for example the show title. |
| `recording_type` | enum | no | audio_video or audio_only. Default: audio_video. |

Creates a studio with the name and recording type you give. Studios count against the limit of your Riverside plan, so a new one can use up a slot. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "studio_id": "std_5t8n22",
  "name": "Interview Series",
  "recording_type": "audio_video",
  "studio_url": "https://riverside.com/studio/interview-series"
}
```

### schedule_session

Add a session to the studio Planner and email the people you invite. Access: write, asks the user first. REST: `POST /api/v1/riverside/schedule_session`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `studio_id` | string | yes | Studio ID from list_studios. |
| `name` | string | yes | Session name, for example the episode title. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `end` | datetime | yes | ISO 8601 with time zone. |
| `guest_emails` | string[] | no | Guests to invite now. Default: none. |

Adds a session at the start and end time you give, in the time zone you set. Each guest in guest_emails gets an invite email with the session details and the studio link; the emailed link works until 24 hours after the start. Only the host, account owner, admins, directors and editors can schedule. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "session_id": "ses_3vq9x7",
  "studio_id": "std_8f2k41",
  "status": "scheduled",
  "start": "2026-10-15T15:00:00+01:00",
  "invited": [
    {
      "email": "guest@example.com",
      "role": "guest",
      "email_sent": true
    }
  ]
}
```

### update_session

Rename or reschedule a session, or change who is invited. Access: write, asks the user first. REST: `POST /api/v1/riverside/update_session`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `session_id` | string | yes | Session ID from list_sessions. |
| `name` | string | no | New session name. |
| `start` | datetime | no | New start, ISO 8601 with time zone. |
| `end` | datetime | no | New end, ISO 8601 with time zone. |

Changes the fields you pass and leaves the rest. When the date or time changes, Riverside emails the guests, producer and audience members that the session was updated, and the Google Calendar invite updates automatically. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "session_id": "ses_3vq9x7",
  "status": "updated",
  "start": "2026-10-16T11:00:00+01:00",
  "end": "2026-10-16T12:00:00+01:00",
  "notified": [
    "guest@example.com"
  ]
}
```

### invite_guest

Email a studio invite for a scheduled session to a guest, producer or audience member. Access: write, asks the user first. REST: `POST /api/v1/riverside/invite_guest`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `session_id` | string | yes | Session ID from list_sessions. |
| `email` | string | yes | Who to invite. |
| `role` | enum | no | guest, producer or audience. Default: guest. |

Adds one person to a scheduled session and sends them an invite email with the session details and the studio link. Role is guest by default. Inviting the same email again resends the invite. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "session_id": "ses_3vq9x7",
  "email": "producer@example.com",
  "role": "producer",
  "email_sent": true
}
```

### cancel_session

Remove a scheduled session from the Planner. Recordings already made are kept. Access: write, asks the user first. REST: `POST /api/v1/riverside/cancel_session`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `session_id` | string | yes | Session ID from list_sessions. |

Cancels the session and removes it from the Planner and the project folder. Recordings that were already made stay in your account. Cancelling cannot be undone with one call; schedule the session again to restore it. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "session_id": "ses_3vq9x7",
  "status": "cancelled"
}
```

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

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

### Connect Riverside to your agent.

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

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

```
Book a recording in my Product Hour studio with guest@example.com next Thursday at 15:00 London time, one hour, called "Episode 42: Pricing your first product", and send the invite. Check the studio is free first.
```

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

```
curl https://cotlet.dev/api/v1/riverside/schedule_session \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"studio_id":"std_8f2k41","name":"Episode 42: Pricing your first product","start":"2026-10-15T15:00:00+01:00","end":"2026-10-15T16:00:00+01:00","guest_emails":["guest@example.com"]}'
```

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

```
{
  "session_id": "ses_3vq9x7",
  "studio_id": "std_8f2k41",
  "status": "scheduled",
  "start": "2026-10-15T15:00:00+01:00",
  "invited": [
    {
      "email": "guest@example.com",
      "role": "guest",
      "email_sent": true
    }
  ]
}
```

## Why use Cotlet for Riverside?

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

## Is there a Riverside MCP server on GitHub?

Yes, in part. Riverside runs its own MCP server in beta for editing, clips and social posting, and a community MCP server on GitHub wraps the Business API. Both stop at what Riverside already exposes: neither schedules sessions or invites guests. Cotlet hosts tools for those jobs, and our team keeps them working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Clone the repo, install it, add your Business API key to each MCP client | Request access, sign in to Riverside once, add one MCP server or API key |
| Plan needed | Business plan with API access, granted to select accounts | Any account that can do the job by hand in Riverside |
| What it covers | What the Business API offers: get and delete recordings, list events | Studios, sessions, invites, recordings, transcripts and downloads |
| When Riverside 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 Riverside session | An API key in a file on your computer | Session encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| 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 Riverside 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 Riverside API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Riverside 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 Business plan or the Riverside MCP?**

No. Cotlet works in your own Riverside account and does not use the Business API, which Riverside gives to select Business accounts, or the official MCP, which needs a Grow, Webinar or Business plan. Scheduling needs the host, account owner, admin, director or editor role.

**Can it edit episodes or post clips?**

No. Editing, clips and social posting are what the official Riverside MCP is built for, and Cotlet does not duplicate them. Cotlet covers sessions, invites, recordings, transcripts and track downloads.

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

No. Every call to create_studio, schedule_session, update_session, invite_guest or cancel_session waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals.

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