# Evite API and MCP server

> Evite has no public API and no official MCP server (checked 11 Oct 2026). Events, guest lists, RSVPs and guest messages can only be handled in the Evite website and apps, and its help center names no developer docs or webhooks.

Online invitations for parties and events: send by email or text, track RSVPs, message guests and set reminders from one host dashboard.

## What is the Evite API?

Cotlet's Evite API exposes 13 endpoints for your own Evite account: list events, get event, list guests, export guest list, create event, update event, duplicate event, add guests, send invitation, update guest RSVP, message guests, set reminders and cancel event. The list_events endpoint returns invitations you host, from My Invitations, with date and status. Each endpoint takes simple JSON inputs like event_id, guest_id or status 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:** 13 (4 read, 9 write)
- **Updated:** 2026-10-11

Evite has no public API and no official MCP server (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Evite with 13 endpoints (4 read, 9 write): your AI agent signs in as you and does the work.

## Does Evite have an official API?

Evite has no public API and no official MCP server (checked 11 Oct 2026). Events, guest lists, RSVPs and guest messages can only be handled in the Evite website and apps, and its help center names no developer docs or webhooks.

| Task | Evite official | Cotlet |
|---|---|---|
| Create and edit invitations | No | Yes |
| Add guests and send the invitation | No | Yes |
| Read guests and RSVPs | No | Yes |
| Export the guest list | Partly: Manual "Export guest list" download in the web app only | Yes |
| Message guests by RSVP status | No | Yes |
| Update a guest RSVP as host | No | Yes |
| Schedule reminders | No | Yes |
| Copy or cancel an event | No | Yes |

Sources: [Evite Help Center: Download Guest List](https://support.evite.com/products/invitations/manage-and-edit-guest-list/download-guest-list), [Evite Help Center: Send a Message to Guests](https://support.evite.com/products/invitations/manage-and-edit-guest-list/send-a-message-to-guests), [Evite Help Center: Invitation Reminder](https://support.evite.com/products/invitations/create-and-edit/invitation-reminder), [Evite Help Center: Add More Guests](https://support.evite.com/products/invitations/manage-and-edit-guest-list/add-more-guests), [Evite Help Center: Upload Guest List - Excel Spreadsheet](https://support.evite.com/products/invitations/manage-and-edit-guest-list/upload-guest-list-excel-spreadsheet), [Evite Help Center: Host Edit Guest Response](https://support.evite.com/products/invitations/manage-and-edit-guest-list/host-edit-guest-response)

## For AI agents

```text
Evite has no public API and no official MCP server (checked 11 Oct 2026). Events, guest lists, RSVPs and guest messages can only be handled in the Evite website and apps, and its help center names no developer docs or webhooks.
Cotlet provides a hosted MCP server and REST API for Evite: 13 tools (4 read, 9 write).
Access       Request access at https://cotlet.dev/app/signup?app=evite; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/evite
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_events, get_event, list_guests, export_guest_list, create_event, update_event, duplicate_event, add_guests, send_invitation, update_guest_rsvp, message_guests, set_reminders, cancel_event
Confirm      update_event, add_guests, send_invitation, message_guests, set_reminders, cancel_event (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/evite-api-mcp-server.md

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

## What can an AI agent do in Evite?

Cotlet is best for hosts and event planners who run recurring parties, offsites or fundraisers on Evite and want RSVPs chased, guests added and reminders set without running or fixing a server.

- **[Chase guests who have not RSVPed](https://cotlet.dev/integrations/evite-api-mcp-server/chase-rsvps)** (runs: weekly): "Message everyone who hasn't RSVPed to the BBQ: we need a head count by Friday. Skip anyone whose invite bounced and tell me who they are." → `list_events`, `get_event`, `list_guests`, `message_guests`, `set_reminders`
- **[Add guests from a spreadsheet and send](https://cotlet.dev/integrations/evite-api-mcp-server/add-guests-to-event)**: "Add everyone in team.csv to the offsite invitation, skip anyone already invited, and show me the list before it goes out." → `list_events`, `list_guests`, `add_guests`
- **Export the guest list with RSVPs**: "Put the final guest list with RSVPs and comments into a spreadsheet for the caterer." → `list_events`, `export_guest_list`
- **Schedule event reminders**: "Set two reminders for the offsite: two days before and the morning of the event." → `get_event`, `set_reminders`
- **Copy last year's event and update it**: "Copy last year's holiday party, move it to 12 Dec at 7 pm and keep the same location." → `list_events`, `duplicate_event`, `update_event`
- **[Record phone RSVPs and get the final head count](https://cotlet.dev/integrations/evite-api-mcp-server/record-rsvps-for-guests)**: "Mark Sam and Priya as attending with 2 people each, they told me on the phone, then give me the final head count and the dietary notes for the caterer." → `list_events`, `get_event`, `list_guests`, `update_guest_rsvp`, `export_guest_list`

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

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

### list_events

Invitations you host, from My Invitations, with date and status. Access: read. REST: `POST /api/v1/evite/list_events`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | upcoming, past or canceled. Default: upcoming. |
| `query` | string | no | Only events whose title contains this text. |
| `limit` | integer | no | 1 to 50. Default: 20. |

Lists the events in your My Invitations. Canceled events are included when you ask for them, so you can find one to reinstate. Use event_id from each item in the other endpoints.

Example response:

```json
{
  "events": [
    {
      "event_id": "ev_7Q2KX9M4",
      "title": "Team offsite dinner",
      "start": "2026-11-14T18:00:00-05:00",
      "status": "upcoming",
      "guests": 42
    },
    {
      "event_id": "ev_3H8WNP6Z",
      "title": "Holiday party 2025",
      "start": "2025-12-13T19:00:00-05:00",
      "status": "past",
      "guests": 58
    }
  ]
}
```

### get_event

Event details: title, host and co-hosts, date, time zone, location, host note and RSVP settings. Access: read. REST: `POST /api/v1/evite/get_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |

Returns one event as you set it in Edit Details, plus its RSVP settings: the RSVP limit and the maximum number of additional guests per RSVP (up to 9). Use it before update_event or set_reminders to see the date and time zone.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "title": "Team offsite dinner",
  "host_name": "Maya Chen",
  "start": "2026-11-14T18:00:00-05:00",
  "time_zone": "America/New_York",
  "location": "Harbor House, 12 Pier St",
  "host_note": "Dinner is on us. Please RSVP by Friday.",
  "rsvp_limit": 60,
  "max_additional_guests": 1,
  "status": "upcoming"
}
```

### list_guests

Guest list with RSVP, party size and comment, plus counts per RSVP status. Access: read. REST: `POST /api/v1/evite/list_guests`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `rsvp` | enum | no | all, yes, no, maybe or no_reply. Default: all. |

Returns the guests of one event as View Guest List shows them: name, email or phone, RSVP, party count and comment. Guests whose invitation was not delivered are listed first. The counts block gives the number of guests per status and the total party count. Guests added through the shareable link appear only after they RSVP.

Example response:

```json
{
  "counts": {
    "yes": 21,
    "no": 4,
    "maybe": 3,
    "no_reply": 14,
    "party_total": 39
  },
  "guests": [
    {
      "guest_id": "g_41a9",
      "name": "Sam Rivera",
      "email": "sam@example.com",
      "rsvp": "no_reply",
      "party_size": null,
      "comment": null,
      "delivery": "delivered"
    },
    {
      "guest_id": "g_41b2",
      "name": "Priya Nair",
      "phone": "+12025550143",
      "rsvp": "yes",
      "party_size": 2,
      "comment": "Vegetarian for both of us",
      "delivery": "delivered"
    }
  ]
}
```

### export_guest_list

The guest list as a file: name, email or phone, RSVP, party count and comment. Access: read. REST: `POST /api/v1/evite/export_guest_list`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |

Runs the same Export guest list download as Manage Event and returns a link to the file with the number of guests in it. It reads only and sends nothing.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "guests": 42,
  "columns": [
    "name",
    "email_or_phone",
    "rsvp",
    "party_count",
    "comment"
  ],
  "url": "https://files.cotlet.example/exports/ev_7Q2KX9M4.csv"
}
```

### create_event

New invitation draft from a gallery design. Nothing is sent until send_invitation. Access: write. REST: `POST /api/v1/evite/create_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `design` | string | yes | Free design from the Evite gallery, by name or keyword. |
| `title` | string | yes | Event title. |
| `start` | datetime | yes | Start, ISO 8601. |
| `time_zone` | string | no | IANA time zone, e.g. America/New_York. |
| `location` | string | no | Venue name or address. |
| `host_name` | string | no | Host name shown on the invitation. |
| `host_note` | string | no | Message from the host. |

Creates a draft from a free design in the Evite gallery and fills the Event Details. The draft reaches no one, and you can change it with update_event, so it runs without asking. Premium designs and Premium upgrades are bought in Evite, not by this tool; Cotlet never pays for you.

Example response:

```json
{
  "event_id": "ev_9R5TLD2A",
  "title": "Offsite dinner",
  "start": "2026-11-14T18:00:00-05:00",
  "time_zone": "America/New_York",
  "status": "draft"
}
```

### update_event

Change event details. Only the fields you pass change. Access: write, asks the user first. REST: `POST /api/v1/evite/update_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `fields` | object | yes | Any of title, host_name, start, time_zone, location, host_note. |

Edits an event like Edit Details: title, host name, date, time, time zone, location and host note, until the event date. Evite does not say whether guests are told about a change, but they see the new details on the invitation. Design text is separate: if the time or place appears in the design, keep both in step. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "updated": [
    "start",
    "location"
  ],
  "start": "2026-12-12T19:00:00-05:00",
  "location": "Harbor House, 12 Pier St"
}
```

### duplicate_event

Copy one of your current or past invitations into a new draft. Access: write. REST: `POST /api/v1/evite/duplicate_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |

Runs Duplicate Invitation: a new draft with the old design and details, to update and send. Works only on invitations created from your own account, not on events from the previous version of Evite. Evite does not say whether guests are copied, so check with list_guests. The copy reaches no one and is just a draft, so it runs without asking.

Example response:

```json
{
  "event_id": "ev_5K1BQC8E",
  "copied_from": "ev_3H8WNP6Z",
  "title": "Holiday party 2025",
  "status": "draft"
}
```

### add_guests

Add guests by email or phone. On an event already sent, they get the invitation right away. Access: write, asks the user first. REST: `POST /api/v1/evite/add_guests`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `guests` | object[] | yes | List of { name, email } or { name, phone }. Text invites: US and Canada numbers only. |

Adds guests the way Add Guests does. On an event that is already sent, each new guest receives the same invitation at once, with the RSVP link. A free invitation holds up to 750 guests and Evite Pro up to 2,500. Text invitations work for US and Canada numbers only, and every number needs a name. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "added": 3,
  "guests": [
    {
      "guest_id": "g_52c1",
      "name": "Dana Reyes",
      "via": "email"
    },
    {
      "guest_id": "g_52c2",
      "name": "Luis Ortega",
      "via": "email"
    },
    {
      "guest_id": "g_52c3",
      "name": "Priya Nair",
      "via": "text"
    }
  ]
}
```

### send_invitation

Send a draft invitation to its guests. Free designs only. Access: write, asks the user first. REST: `POST /api/v1/evite/send_invitation`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |

Sends the draft to every guest on its list. It works for free invitations. A Premium invitation is charged by guest list size in Evite, so the call stops with payment_required and you finish it in Evite. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_9R5TLD2A",
  "status": "sent",
  "invited": 42,
  "sent_at": "2026-10-14T09:30:00-04:00"
}
```

### update_guest_rsvp

Set a guest's response and party size as host. The guest is not notified. Access: write. REST: `POST /api/v1/evite/update_guest_rsvp`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `guest_id` | string | yes | Guest ID from list_guests. |
| `response` | enum | yes | yes, no or maybe. |
| `party_size` | integer | no | Number of people in the party. |

Does what Edit under View Guest List does: sets the response to yes, no or maybe, with a guest count. Evite does not tell the guest, and guests can still change their own answer later. It reaches no one and one more call undoes it, so it runs without asking.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "guest_id": "g_41a9",
  "rsvp": "yes",
  "party_size": 2,
  "guest_notified": false
}
```

### message_guests

Send a message to a group by RSVP status or to one guest. Each guest gets it privately. Access: write, asks the user first. REST: `POST /api/v1/evite/message_guests`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `body` | string | yes | Message text. |
| `group` | enum | no | all, attending, declined or no_reply. Default: all. |
| `guest_id` | string | no | Send to this one guest instead of a group. |

Runs Send Message from Guest Options. Groups are all, attending, declined and no_reply (still no response). Each guest receives the message on their own, so guests never see each other's email addresses. Evite sets no cap on messages. To write to one guest, pass guest_id. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "status": "sent",
  "group": "no_reply",
  "recipients": 14,
  "sent_at": "2026-10-14T18:05:00-04:00"
}
```

### set_reminders

Replace the event's reminders. Up to 5, each at least 30 minutes from now. Access: write, asks the user first. REST: `POST /api/v1/evite/set_reminders`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `send_at` | string[] | yes | Up to 5 ISO 8601 datetimes. Empty list removes all. |

Replaces the reminders of Manage Event with the times you pass. Each must be at least 30 minutes from now and no later than 30 minutes before the event starts; an empty list removes them all, including the automatic one. Reminders go to guests who have not replied and to Yes and Maybe guests. The text is Evite's own and cannot be changed. Not available when RSVPs are off. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "event_start": "2026-11-14T18:00:00-05:00",
  "reminders": [
    "2026-11-12T18:00:00-05:00",
    "2026-11-14T10:00:00-05:00"
  ]
}
```

### cancel_event

Cancel an event before its date, optionally with a note to guests. Evite lets you reinstate it. Access: write, asks the user first. REST: `POST /api/v1/evite/cancel_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `message` | string | no | Note sent to guests with the cancellation. |

Runs Cancel Event from My Invitations, with the optional personal message to guests that Evite asks for after cancelling. Evite does not say guests get an automatic notice, so pass message when they should hear it. The host can reinstate the event in Evite any time before its original date. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_7Q2KX9M4",
  "status": "canceled",
  "message_sent": true
}
```

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

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

### Connect Evite to your agent.

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

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

```
Message everyone who hasn't RSVPed to the BBQ: we need a head count by Friday. Skip anyone whose invite bounced and tell me who they are.
```

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

```
curl https://cotlet.dev/api/v1/evite/message_guests \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"event_id":"ev_7Q2KX9M4","group":"no_reply","body":"Quick nudge: please RSVP by Friday so we can order food. Thanks!"}'
```

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

```
{
  "event_id": "ev_7Q2KX9M4",
  "status": "sent",
  "group": "no_reply",
  "recipients": 14,
  "sent_at": "2026-10-14T18:05:00-04:00"
}
```

## Why use Cotlet for Evite?

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

## Is there a Evite MCP server on GitHub?

Yes. A community Evite MCP server exists on GitHub, maintained by one person. It talks to Evite's internal web endpoints, you install and fix it yourself, and it stops when Evite changes its site. Cotlet hosts the same kind of server for you, and our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Clone the repo, install it, give it your Evite login or a copied cookie, add it to each MCP client | Request access, sign in to Evite once in your browser, add one MCP server or API key |
| When Evite 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 Evite session | A password in an env var or a cookie in a file on your computer | Session only, encrypted in an EU vault; we never keep your password; revoked in one click |
| When the session expires | Tools fail until you sign in again by hand | If Evite logs you out, your agent gets a link to sign in again |
| Upkeep | You update, monitor and debug it yourself | Nothing to host or update |
| 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 Evite 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 Evite API cost?

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

**Do I need to be technical?**

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

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

**How many guests can an Evite event have?**

A free invitation supports up to 750 guests and Evite Pro up to 2,500, per Evite's Guest List Limit help page (checked 11 Oct 2026). You can also set an RSVP limit in Manage Event; responses close when it is reached.

**Can the agent pay for a Premium invitation?**

No. Premium designs are charged by guest list size when you send in Evite, and Cotlet does not enter payment details. The agent drafts and sends free invitations and leaves the Premium purchase to you.

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

No. Every call to update_event, add_guests, send_invitation, message_guests, set_reminders or cancel_event waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. create_event, duplicate_event, update_guest_rsvp runs without asking, because it sends nothing to anyone and one call undoes it.

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