Connect Eventee to ChatGPT: Manage Events, Speakers, and Agenda

If you need to connect Eventee to ChatGPT to automate event logistics, manage speaker line-ups, or orchestrate attendee invitations, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Eventee's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Eventee to Claude or explore our broader architectural overview on connecting Eventee to AI Agents.

Giving a Large Language Model (LLM) read and write access to a live event management platform like Eventee is a massive engineering challenge. You have to handle complex relational data payloads, map dynamic scheduling entities to MCP tool definitions, and deal with bulk lifecycle operations. Every time a schedule shifts or a speaker drops out, your automated systems must resolve multiple foreign keys - halls, tracks, and session times - perfectly.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Eventee, connect it natively to ChatGPT, and execute complex event workflows using natural language.

The Engineering Reality of the Eventee API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Eventee's highly relational API is exceptionally painful.

If you decide to build a custom MCP server for Eventee, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Eventee:

1. Relational Graph Complexity for Lectures

When an LLM attempts to create or update a session (referred to as a "lecture" in Eventee), it cannot simply pass a string of text. A lecture requires precise mapping to a hall_id, an array of speakers, and an array of tracks. If ChatGPT hallucinates a hall name instead of providing the exact UUID of the physical room, the API will reject the payload. Your MCP server must expose specific discovery tools - like listing all halls and tracks - so the LLM can resolve these foreign keys before attempting a write operation.

2. Temporal Validation and Agenda Collisions

Eventee enforces strict temporal constraints. A pause (break) or a lecture cannot exist outside the overarching event's start and end timestamps. Furthermore, overlapping sessions in the same physical hall often trigger validation errors. When exposing these endpoints to an AI agent, the MCP tools must clearly dictate ISO 8601 formatting requirements in their JSON Schema descriptions, explicitly instructing the model to verify hall availability before scheduling.

3. Rate Limiting and Retry Responsibility

When automating bulk invites or mass agenda updates, you will encounter rate limits. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Eventee API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller.

To help you handle this, Truto normalizes upstream rate limit information into standardized headers per the IETF specification:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

The caller (your AI framework or agent loop) is entirely responsible for reading these headers, pausing execution, and applying exponential backoff.

Step 1: Create the Eventee MCP Server

Truto automatically generates MCP tool definitions from Eventee's API documentation and OpenAPI schemas. To expose these tools to ChatGPT, you must first create an MCP server scoped to a specific integrated Eventee account.

You can do this via the Truto UI or programmatically via the API.

Method A: Via the Truto UI

For one-off agent configurations or internal operations, the dashboard is the fastest route:

1. Log into your Truto account and navigate to Integrated Accounts.
2. Select your connected Eventee account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., filter by read and write methods, or tag filters like agenda and attendees).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method B: Via the API

For production use cases where you are provisioning AI agents programmatically on behalf of your users, you should generate the MCP server via the Truto API.

Make a POST request to /integrated-account/:id/mcp, passing in the specific configuration you want to expose to the LLM.

curl -X POST https://api.truto.one/integrated-account/YOUR_INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Eventee Agenda Manager Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["lectures", "speakers", "participants"]
    }
  }'

The API will return a JSON response containing the secure, authenticated URL:

{
  "id": "mcp_evt_8899aabb",
  "name": "Eventee Agenda Manager Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["lectures", "speakers", "participants"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/abc123def4567890"
}

Treat this url as a highly sensitive credential. It contains a cryptographically hashed token that grants direct access to the Eventee instance.

Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it as a custom connector in ChatGPT. You can do this through the ChatGPT user interface or via a manual configuration file if you are running a local MCP transport.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the server directly in the browser:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under MCP servers / Custom connectors, click Add new server.
4. Enter a descriptive name (e.g., "Eventee Production").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Add and save your settings.

ChatGPT will immediately perform a JSON-RPC initialize handshake with Truto, fetch the available Eventee tools via tools/list, and make them available in your chat context.

Method B: Via Manual Config File (Local / CLI Agents)

If you are wrapping ChatGPT in a custom agent framework, running a local orchestration loop, or using the official MCP CLI tools, you can connect using a JSON configuration file and the SSE transport.

Create an mcp_config.json file:

{
  "mcpServers": {
    "eventee_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/abc123def4567890"
      ]
    }
  }
}

When your agent initializes, it will use the SSE transport to connect to Truto's edge router and discover the Eventee tools dynamically.

Hero Tools for Eventee

Truto automatically generates precise, JSON-Schema-backed tools for Eventee. Below are the highest-leverage operations for event automation.

List All Eventee Speakers

Retrieves the complete roster of speakers for the event, including their biographies, company affiliations, and linked social media accounts. This is critical for agents needing context before assigning speakers to new lectures.

"Fetch the current list of all speakers for the tech conference. I need to know which company John Doe represents before we assign him to the keynote slot."

Create an Eventee Lecture

Schedules a new session on the agenda. The agent must supply a name, start time, end time, and resolve the correct foreign keys for hall_id, speakers, and tracks.

"Schedule a new panel called 'Future of AI' from 2:00 PM to 3:00 PM tomorrow. Place it in the Main Hall and assign Sarah Jenkins as the primary speaker."

Update an Eventee Partner by ID

Modifies the profile of an event sponsor or exhibitor. This tool handles complex nested objects containing company descriptions, contact emails, physical addresses, and specific exhibitor tier information.

"Update the partner profile for Acme Corp. Change their booth location in the description to 'Zone B, Booth 45' and ensure their contact email is set to sponsorships@acmecorp.com."

Invite Eventee Participants

Dispatches official event invitations to a list of attendees. The API generates unique QR codes and access URLs for each invited participant, which the agent can retrieve and pass along to a downstream email tool.

"Send official event invites to the VIP list containing alice@example.com and bob@example.com. Return their generated QR code URLs so I can draft their welcome emails."

List All Eventee Participants

Extracts the attendee directory, returning check-in status, registration timestamps, roles, and group IDs. Useful for running real-time analytics on event attendance or finding stragglers.

"Pull the list of all event participants and identify anyone who registered in the last 24 hours but has not yet checked in."

Bulk Delete Eventee Event Content

Clear all test content from an Eventee event. This tool destructively deletes every hall, lecture, track, pause, speaker, and workshop from the event in one call. It is highly dangerous and should only be exposed to agents managing staging environments or resetting templates.

"Wipe the staging event completely clean. Delete all existing lectures, speakers, halls, and tracks so we can import the fresh schedule."

To view the complete inventory of available Eventee operations, endpoints, and exact JSON schema requirements, visit the Eventee integration page.

Workflows in Action

Exposing these tools to an LLM transforms tedious event logistics into natural language commands. Here is how ChatGPT orchestrates multi-step Eventee workflows using Truto's MCP server.

Scenario 1: Last-Minute Agenda Reorganization

An event manager finds out a keynote speaker's flight is delayed. They need to swap a lecture's time slot and update the associated track.

"John Doe is delayed. Find his 'Intro to Kubernetes' lecture. Move its start time back by exactly two hours. Then, fetch all attendees so we can notify them of the change."

Step-by-step execution:

1. list_all_eventee_speakers: ChatGPT queries the speakers to find John Doe's exact database ID.
2. list_all_eventee_lectures (Standard read tool): ChatGPT searches the agenda for lectures containing John Doe's ID to retrieve the specific lecture ID for 'Intro to Kubernetes'.
3. update_a_eventee_lecture_by_id: The agent submits a PATCH payload, advancing the start and end timestamps by two hours while retaining the existing hall_id and tracks.
4. list_all_eventee_participants: The agent pulls the attendee list, paginating via next_cursor until it has a complete list of emails to hand back to the user for the notification blast.

sequenceDiagram
    participant User as Event Manager
    participant Agent as ChatGPT
    participant Truto as Truto MCP Server
    participant Upstream as Eventee API
    
    User->>Agent: "Move John Doe's lecture back 2 hours..."
    Agent->>Truto: call list_all_eventee_speakers
    Truto->>Upstream: GET /speakers
    Upstream-->>Truto: [{id: 42, name: "John Doe"}]
    Truto-->>Agent: speaker ID 42
    
    Agent->>Truto: call list_all_eventee_lectures
    Truto->>Upstream: GET /lectures
    Upstream-->>Truto: [{id: 105, name: "Intro to K8s", start: "10:00"}]
    Truto-->>Agent: lecture ID 105
    
    Agent->>Truto: call update_a_eventee_lecture_by_id (id: 105, start: "12:00")
    Truto->>Upstream: PUT /lectures/105
    Upstream-->>Truto: 200 OK
    Truto-->>Agent: Success

Scenario 2: VIP Partner Onboarding

A sponsorship coordinator needs to rapidly onboard a new top-tier sponsor, create their profile, and invite their executive team to the app.

"Create a new partner profile for 'Global Tech' with the description 'Platinum Sponsor'. Once created, send event invites to their execs: ceo@globaltech.com and cto@globaltech.com."

Step-by-step execution:

1. create_a_eventee_partner: ChatGPT constructs the JSON body required for a partner, setting the company string to "Global Tech" and injecting the provided description.
2. eventee_participants_invite: The agent takes the two provided email addresses and invokes the bulk invite tool.
3. Formatting the Output: The agent parses the returned qr_code and url fields from the invite response and presents them to the user in a clean markdown table.

Security and Access Control

When granting AI models write access to a live event database, security is paramount. Truto's MCP servers provide strict, token-level governance over what the LLM can execute.

• Method Filtering: Limit your agent's blast radius. Set methods: ["read"] to restrict the server to GET and LIST operations. The LLM can view the agenda but cannot delete lectures or invite users.
• Tag Filtering: Restrict access by business domain. Setting tags: ["agenda"] ensures the agent only sees tools related to halls, pauses, tracks, and lectures, while blinding it to financial or partner data.
• Enforced API Token Auth: By default, possessing the MCP URL grants access. By enabling require_api_token_auth: true, you force the client (ChatGPT) to pass a valid Truto API token in the Authorization header, adding a mandatory secondary authentication layer.
• Time-To-Live Expiration: For temporary contractor access or limited-duration agent tasks, pass an expires_at timestamp during server creation. Truto automatically destroys the token and revokes access at the exact millisecond requested.
• Zero Data Retention: Truto acts as a pass-through proxy for MCP tool calls. Payloads, attendee lists, and agenda details are routed in memory, never persisted to Truto's databases.

Stop Writing Boilerplate Event Code

Connecting ChatGPT to Eventee shouldn't require weeks of parsing nested relational schemas, managing OAuth tokens, or writing fragile integration scripts to handle rate limits.

By leveraging Truto's auto-generated MCP servers, you can give your AI agents secure, schema-perfect access to Eventee's entire feature set in a matter of seconds. Let the agents handle the scheduling logistics so your team can focus on running a flawless event.