# Whova API and MCP server

> Whova has no public developer API (checked 11 Oct 2026). Organizers get a Zapier app with three triggers (attendees, orders, registrants) and one action, Create or Update Attendee, plus native connections to CRM and AMS platforms such as HubSpot and MemberClicks.

Event management platform for conferences and trade shows: registration and ticketing, agenda, event app, announcements, speakers, sponsors and a post-event report.

## What is the Whova API?

Cotlet's Whova API exposes 11 endpoints for your own Whova account: list events, list attendees, list registrations, list sessions, list speakers, get post-event report, add session, update session, add attendee, send announcement and message speakers. The list_events endpoint returns events you can manage as an organizer, with dates and status. Each endpoint takes simple JSON inputs like event_id, ticket_type or title 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:** 11 (6 read, 5 write)
- **Updated:** 2026-10-11

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

## Does Whova have an official API?

Whova has no public developer API (checked 11 Oct 2026). Organizers get a Zapier app with three triggers (attendees, orders, registrants) and one action, Create or Update Attendee, plus native connections to CRM and AMS platforms such as HubSpot and MemberClicks.

| Task | Whova official | Cotlet |
|---|---|---|
| List attendees | Partly: Zapier trigger Get Attendees fires when the list changes; no ad hoc queries | Yes |
| List registrations and orders | Partly: Zapier triggers Get Orders and Get Registrants | Yes |
| Add or update attendees | Partly: Zapier action Create or Update Attendee, one attendee per run | Yes |
| Add or edit agenda sessions | No: Whova imports agendas from a spreadsheet and edits them in Session Manager, both in the dashboard | Yes |
| Send announcements to attendees | No | Yes |
| Email speakers | No: Speaker messaging portal in the dashboard only | Yes |
| Read the post-event report | No | Yes |

Sources: [Whova on Zapier: triggers and actions](https://zapier.com/apps/whova/integrations), [Whova: CRM and AMS integrations, other platforms through Zapier](https://whova.com/blog/update-hubspot-with-whova-registration-data/), [Whova: speaker management, Session Manager and spreadsheet agenda import](https://whova.com/speaker-management-software/), [Whova: event management features and post-event report](https://whova.com/event-management-software/), [Whova: Session Manager Bulk Move tool](https://whova.com/blog/bulk-move-sessions/), [Whova: custom session list import and re-import by Session ID](https://whova.com/blog/custom-session-list-import/), [Whova: Message Speakers by role in Speaker Center](https://whova.com/blog/message-speakers-by-role/), [Whova: requesting the post-event report](https://whova.com/blog/faster-post-event-report-access/)

## For AI agents

```text
Whova has no public developer API (checked 11 Oct 2026). Organizers get a Zapier app with three triggers (attendees, orders, registrants) and one action, Create or Update Attendee, plus native connections to CRM and AMS platforms such as HubSpot and MemberClicks.
Cotlet provides a hosted MCP server and REST API for Whova: 11 tools (6 read, 5 write).
Access       Request access at https://cotlet.dev/app/signup?app=whova; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/whova
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_events, list_attendees, list_registrations, list_sessions, list_speakers, get_post_event_report, add_session, update_session, add_attendee, send_announcement, message_speakers
Confirm      add_attendee, send_announcement, message_speakers (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/whova-api-mcp-server.md

How access works:
1. The user requests access at https://cotlet.dev/app/signup?app=whova (Whova is pre-selected). Each request is reviewed and the API key is sent by email.
2. The user signs in to Whova 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 Whova server that someone else maintains, including non-developers.

Policy: Cotlet never stores passwords, never solves CAPTCHAs, never bypasses MFA.
Company: legal details in the Terms of service at https://cotlet.dev/terms. Contact contact@cotlet.dev.
Session: the user signs in to Whova 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 Whova's terms; Cotlet is not affiliated with Whova.
```

## What can an AI agent do in Whova?

Cotlet is best for event organizers who run Whova events and want their AI agent to handle agenda changes, announcements, speaker emails and registration lists without running or fixing a server.

- **[Update agenda sessions after a schedule change](https://cotlet.dev/integrations/whova-api-mcp-server/update-agenda-sessions)**: "The venue took our Room 2 on day 2: move the four afternoon breakouts in the Workshops track to start at 3:00 PM, keep their lengths, check no speaker ends up in two places, then draft an announcement for attendees." → `list_sessions`, `update_session`, `add_session`, `send_announcement`
- **Import a program into the agenda**: "Add the 12 sessions from program.xlsx to the agenda of my October summit." → `list_events`, `add_session`
- **Announce a change to all attendees**: "Tell all attendees that the keynote moved to Hall B." → `send_announcement`
- **[Email speakers their own session details](https://cotlet.dev/integrations/whova-api-mcp-server/email-speakers-session-details)**: "Email every speaker of the Northwind Summit their own sessions with times, track and co-presenters, plus our AV guidelines. Show me one draft before sending." → `list_speakers`, `list_sessions`, `message_speakers`
- **Export registrations and attendees** (runs: daily): "List everyone who registered since yesterday with their ticket type." → `list_events`, `list_registrations`
- **[Turn the post-event report into sponsor recaps](https://cotlet.dev/integrations/whova-api-mcp-server/sponsor-recap-from-post-event-report)**: "Read the post-event report of Northwind Summit 2025 and draft a recap for each sponsor with their own impressions next to the event totals. Do not send anything." → `list_events`, `get_post_event_report`

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

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

## Tools

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

### list_events

Events you can manage as an organizer, with dates and status. Access: read. REST: `POST /api/v1/whova/list_events`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | upcoming, past or all. Default: upcoming. |

Returns every event of your organizer account, newest first. Use event_id from each item in the other tools. Dates are in the time zone of the event.

Example response:

```json
{
  "events": [
    {
      "event_id": "284611",
      "name": "Northwind Summit 2026",
      "start": "2026-10-21",
      "end": "2026-10-23",
      "status": "upcoming"
    },
    {
      "event_id": "271905",
      "name": "Northwind Summit 2025",
      "start": "2025-10-14",
      "end": "2025-10-16",
      "status": "past"
    }
  ]
}
```

### list_attendees

Attendees of an event with email, company, ticket type, audience type and check-in status. Access: read. REST: `POST /api/v1/whova/list_attendees`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `ticket_type` | string | no | Only holders of this ticket type, as named in your event. |
| `audience_type` | string | no | Only attendees with this audience type, as named in your event. |
| `checked_in` | boolean | no | true for checked-in attendees, false for those not checked in. |
| `limit` | integer | no | 1 to 500. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists attendees of one event. Filter by ticket type or audience type, or by check-in status to see who has not arrived. Pages hold up to 500 attendees; pass next_cursor back as cursor for the next page.

Example response:

```json
{
  "attendees": [
    {
      "attendee_id": "at_5521",
      "first_name": "Maya",
      "last_name": "Ortiz",
      "email": "maya@example.com",
      "company": "Northwind Labs",
      "ticket_type": "Full Pass",
      "audience_type": "Attendee",
      "checked_in": false
    }
  ],
  "next_cursor": null
}
```

### list_registrations

Registration orders with registrant, ticket type and order date, newest first. Access: read. REST: `POST /api/v1/whova/list_registrations`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `since` | date | no | Only orders placed on or after this date. |
| `ticket_type` | string | no | Only orders with this ticket type. |
| `limit` | integer | no | 1 to 500. Default: 100. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists registration orders of one event, newest first. Filter by date or ticket type to get only what is new since your last check. Pages hold up to 500 orders; pass next_cursor back as cursor.

Example response:

```json
{
  "orders": [
    {
      "order_id": "ord_80231",
      "registrant": "Maya Ortiz",
      "email": "maya@example.com",
      "ticket_type": "Full Pass",
      "ordered_at": "2026-10-10T14:12:00Z"
    },
    {
      "order_id": "ord_80229",
      "registrant": "Leo Brandt",
      "email": "leo@example.com",
      "ticket_type": "Student",
      "ordered_at": "2026-10-10T09:40:00Z"
    }
  ],
  "next_cursor": null
}
```

### list_sessions

Agenda sessions with time, tracks, speakers and description, in agenda order. Access: read. REST: `POST /api/v1/whova/list_sessions`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `date` | date | no | Only sessions on this day. |
| `track` | string | no | Only sessions in this track. |

Lists the sessions of one event in agenda order. Filter by day or track. Use session_id with update_session. Times carry the time zone of the event.

Example response:

```json
{
  "sessions": [
    {
      "session_id": "s_30871",
      "title": "Breakout: Pricing workshop",
      "start": "2026-10-22T14:00:00-07:00",
      "end": "2026-10-22T15:00:00-07:00",
      "tracks": [
        "Workshops"
      ],
      "speakers": [
        "Jon Pike"
      ]
    }
  ]
}
```

### list_speakers

Speakers of an event from the Speaker Center, with their sessions. Access: read. REST: `POST /api/v1/whova/list_speakers`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `session_id` | string | no | Only speakers of this session. |

Lists the speakers of one event with the sessions each one speaks in. Speakers added to a session appear here automatically. Use it to build the recipient list for message_speakers.

Example response:

```json
{
  "speakers": [
    {
      "speaker_id": "sp_204",
      "name": "Dana Reyes",
      "email": "dana@example.com",
      "sessions": [
        "Opening keynote"
      ]
    }
  ]
}
```

### get_post_event_report

The post-event report of an event as text sections, available after the event ends. Access: read. REST: `POST /api/v1/whova/get_post_event_report`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `section` | string | no | Section title as shown in the report. Default: all sections. |

Returns the post-event report of one finished event as titled sections with their figures. Pass section to read one part, for example Sponsors and exhibitors. Whova releases the report only after the organizer requests it under Tools > Report; until then the call fails with a not-ready error.

Example response:

```json
{
  "event_id": "271905",
  "sections": [
    {
      "title": "Sponsors and exhibitors",
      "text": "Total sponsor impressions, exhibitor leads and attendee profile views, then impressions per sponsor."
    }
  ]
}
```

### add_session

Add a session to the agenda in Session Manager. Access: write. REST: `POST /api/v1/whova/add_session`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `title` | string | yes | Session title. |
| `start` | datetime | yes | Start, ISO 8601 with time zone. |
| `end` | datetime | yes | End, ISO 8601 with time zone. |
| `tracks` | string[] | no | Tracks the session belongs to, as named in your event. |
| `speakers` | string[] | no | Speaker names. |
| `description` | string | no | Session description. |

Creates one session in the agenda of one event. Speakers you name also appear in the Speaker Center. The session shows in the event app agenda at once. It reaches no one directly and one update_session or a delete in Whova undoes it, so it runs without asking.

Example response:

```json
{
  "session_id": "s_30902",
  "event_id": "284611",
  "title": "Opening keynote",
  "start": "2026-10-21T09:00:00-07:00",
  "end": "2026-10-21T09:45:00-07:00",
  "tracks": [
    "Main stage"
  ],
  "speakers": [
    "Dana Reyes"
  ],
  "status": "created"
}
```

### update_session

Change the time, tracks, speakers or description of an existing session. Access: write. REST: `POST /api/v1/whova/update_session`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `session_id` | string | yes | Session ID from list_sessions. |
| `title` | string | no | New title. |
| `start` | datetime | no | New start, ISO 8601 with time zone. |
| `end` | datetime | no | New end, ISO 8601 with time zone. |
| `tracks` | string[] | no | Replaces the tracks. |
| `speakers` | string[] | no | Replaces the speakers. |
| `description` | string | no | New description. |

Changes the fields you send and leaves the others as they are. Moving a block of sessions means one call per session. It reaches no one directly and one more call restores the old values, so it runs without asking.

Example response:

```json
{
  "session_id": "s_30871",
  "event_id": "284611",
  "title": "Breakout: Pricing workshop",
  "start": "2026-10-22T15:00:00-07:00",
  "end": "2026-10-22T16:00:00-07:00",
  "status": "updated"
}
```

### add_attendee

Create or update one attendee by name and email. Access: write, asks the user first. REST: `POST /api/v1/whova/add_attendee`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `first_name` | string | yes | First name. |
| `last_name` | string | yes | Last name. |
| `email` | string | yes | Attendee email. |
| `company` | string | no | Company or organization. |
| `title` | string | no | Job title. |
| `ticket_type` | string | no | Ticket type, as named in your event. |
| `audience_type` | string | no | Audience type, as named in your event. |

Creates the attendee, or updates the one with the same email. The attendee appears in the event's attendee list. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "attendee_id": "at_5530",
  "event_id": "284611",
  "email": "sam@example.com",
  "status": "created"
}
```

### send_announcement

Post an announcement for the attendees of an event. Access: write, asks the user first. REST: `POST /api/v1/whova/send_announcement`.

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

Posts an announcement to the attendees of one event. App users get it as a push notification, and Whova also connects announcements to attendees' email, so people without the app are notified. It reaches every attendee at once. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "announcement_id": "ann_90314",
  "event_id": "284611",
  "status": "sent"
}
```

### message_speakers

Email all speakers of an event, or the ones you list, through Whova. Access: write, asks the user first. REST: `POST /api/v1/whova/message_speakers`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `subject` | string | yes | Email subject. |
| `body` | string | yes | Email body. |
| `speaker_ids` | string[] | no | Speaker IDs from list_speakers. Default: all speakers. |

Sends an email to speakers through Whova's speaker messaging. Leave speaker_ids out to email all speakers of the event. Speakers receive it from Whova, not from your own address. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "message_id": "msg_4107",
  "event_id": "284611",
  "recipients": 18,
  "status": "sent"
}
```

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

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

### Connect Whova to your agent.

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

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

```
The venue took our Room 2 on day 2: move the four afternoon breakouts in the Workshops track to start at 3:00 PM, keep their lengths, check no speaker ends up in two places, then draft an announcement for attendees.
```

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

```
curl https://cotlet.dev/api/v1/whova/send_announcement \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"event_id":"284611","message":"The opening keynote has moved to Hall B. Doors open at 8:45."}'
```

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

```
{
  "announcement_id": "ann_90314",
  "event_id": "284611",
  "status": "sent"
}
```

## Why use Cotlet for Whova?

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

## Is there a Whova MCP server on GitHub?

No open-source Whova MCP server exists. The realistic option is Zapier, which reads new attendees, orders and registrants and can create or update one attendee, but cannot touch the agenda, announcements or speaker emails.

|  | Zapier | Cotlet |
|---|---|---|
| Setup | Connect Whova in Zapier, then build a Zap per workflow | Request access, sign in to Whova once, add one MCP server or API key |
| What it covers | Attendees, orders and registrants; one write action for attendees | Agenda sessions, announcements, speaker emails and the post-event report as well |
| Ad hoc questions | Fixed Zaps that fire when records change | Your agent reads attendees, agenda and reports when you ask |
| When Whova changes | Maintained by Whova and Zapier | Our team tests it daily and fixes it for you; failed calls are free |
| Your Whova session | Zapier connection managed by Zapier | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| Where it runs | Zapier cloud | Hosted: Claude Code, Codex, Cursor, n8n and scripts, also on a schedule |
| Price | A Zapier plan for multi-step or frequent Zaps | 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 Whova 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 Whova API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your Whova 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 Zapier or a special Whova plan?**

No. Cotlet works in your own Whova organizer account and does not use the Zapier app. You need an account that can manage the event in the Whova dashboard.

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

No. Every call to add_attendee, send_announcement or message_speakers waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals. add_session, update_session runs without asking, because it sends nothing to anyone and one call undoes it.

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