# DICE API and MCP server

> DICE has a read-only partner API, the Ticket Holders GraphQL API, with a token you generate in MIO (checked 11 Oct 2026). It reads events, tickets, orders, returns and transfers, and documents no mutations, so it cannot create events, change ticket types or message fans.

Mobile ticketing app for gigs, club nights and festivals; promoters and venues run their events in its partner dashboard, MIO.

## What is the DICE API?

Cotlet's DICE API exposes 15 endpoints for your own DICE account: list events, get event, get sales summary, list orders, list ticket holders, list returns, list transfers, create event, add ticket type, add price tier, update ticket type, submit event, update event, message attendees and cancel event. The list_events endpoint returns your events in MIO with state, dates, venue and total allocation. Each endpoint takes simple JSON inputs like event_id, since or cursor 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:** 15 (7 read, 8 write)
- **Updated:** 2026-10-11

DICE has a read-only partner API, the Ticket Holders GraphQL API, with a token you generate in MIO (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for DICE with 15 endpoints (7 read, 8 write): your AI agent signs in as you and does the work.

## Does DICE have an official API?

DICE has a read-only partner API, the Ticket Holders GraphQL API, with a token you generate in MIO (checked 11 Oct 2026). It reads events, tickets, orders, returns and transfers, and documents no mutations, so it cannot create events, change ticket types or message fans.

| Task | DICE official | Cotlet |
|---|---|---|
| List events and their state | Yes: Ticket Holders API, viewer events | Yes |
| List ticket holders for an event | Yes: Ticket Holders API, tickets | Yes |
| Sales by ticket type and channel | Partly: Raw orders only, you add them up yourself | Yes |
| Returns and transfers | Yes: Ticket Holders API, returns and ticket transfers | Yes |
| Create an event draft and submit it | No | Yes |
| Add or change ticket types and price tiers | No: The API reads them, it cannot write them | Yes |
| Change date, venue or line-up | No | Yes |
| Cancel an event or message attendees | No | Yes |

Sources: [DICE Ticket Holders API reference](https://partners-endpoint.dice.fm/graphql/docs/index.html), [MIO ticketing terms (US)](https://support.dice.fm/article/764-mio-ticketing-terms-and-conditions-us), [DICE for partners](https://dice.fm/partners/ticketing), [Make It On DICE: User Guidelines (MIO Connect)](https://support.dice.fm/article/761-mio-user-guidelines-english-language)

## For AI agents

```text
DICE has a read-only partner API, the Ticket Holders GraphQL API, with a token you generate in MIO (checked 11 Oct 2026). It reads events, tickets, orders, returns and transfers, and documents no mutations, so it cannot create events, change ticket types or message fans.
Cotlet provides a hosted MCP server and REST API for DICE: 15 tools (7 read, 8 write).
Access       Request access at https://cotlet.dev/app/signup?app=dice; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/dice
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        list_events, get_event, get_sales_summary, list_orders, list_ticket_holders, list_returns, list_transfers, create_event, add_ticket_type, add_price_tier, update_ticket_type, submit_event, update_event, message_attendees, cancel_event
Confirm      add_ticket_type, add_price_tier, update_ticket_type, submit_event, update_event, message_attendees, 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/dice-api-mcp-server.md

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

## What can an AI agent do in DICE?

Cotlet is best for DICE promoters and venues who want their AI agent to set up events, adjust ticket tiers and pull sales and guest lists without running or fixing a server.

- **[Weekly ticket sales report with returns and transfers](https://cotlet.dev/integrations/dice-api-mcp-server/weekly-ticket-sales-report)** (runs: weekly): "Every Monday, give me last week's DICE sales for every show on sale: tickets per ticket type, door and external sales apart, and the returns and transfers since last Monday." → `list_events`, `get_sales_summary`, `list_returns`, `list_transfers`
- **[Create an event draft with ticket types](https://cotlet.dev/integrations/dice-api-mcp-server/create-event-draft)**: "Set up a DICE draft for our 14 Nov club night at The Warehouse, 22:00 to 04:00, 18+, DJ Orla and Kest, announce 15 Oct and on sale 16 Oct, with early bird at 15 USD for 100 and general admission at 20 USD for 250." → `list_events`, `create_event`, `add_ticket_type`
- **[Add a ticket release when early bird sells out](https://cotlet.dev/integrations/dice-api-mcp-server/add-ticket-release)**: "Early bird for Club Night is almost gone. Check how fast it is selling and add a second release at 18 USD for 150 tickets." → `list_events`, `get_event`, `get_sales_summary`, `add_price_tier`
- **Export the ticket holder list for the door**: "Export the ticket holders for tonight as a CSV for the door team." → `list_events`, `list_ticket_holders`
- **Track ticket returns and transfers** (runs: weekly): "Every Monday, send me returns and transfers for all upcoming events." → `list_events`, `list_returns`, `list_transfers`
- **[Update an event and message ticket holders](https://cotlet.dev/integrations/dice-api-mcp-server/announce-event-change)**: "Doors for Club Night moved from 22:00 to 20:00. Update the event and tell everyone with a ticket that their ticket is still valid." → `get_event`, `update_event`, `message_attendees`

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

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

## Tools

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

### list_events

Your events in MIO with state, dates, venue and total allocation. Access: read. REST: `POST /api/v1/dice/list_events`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `state` | enum | no | draft, submitted, review, approved, declined, cancelled or archived. Default: all. |
| `starts_after` | date | no | Only events starting on or after this date. |
| `starts_before` | date | no | Only events starting before this date. |
| `limit` | integer | no | 1 to 100. Default: 25. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the events of your MIO account, soonest first. Filter by state or start date to find tonight's show or everything still in draft. Use the event_id from each item in the other tools. Pages hold up to 100 events; pass next_cursor back as cursor.

Example response:

```json
{
  "events": [
    {
      "event_id": "ev_48213",
      "name": "Club Night",
      "state": "approved",
      "start": "2026-11-14T22:00:00+00:00",
      "venue": "The Warehouse",
      "allocation": 350
    },
    {
      "event_id": "ev_48377",
      "name": "Rooftop Session",
      "state": "draft",
      "start": "2026-12-05T19:00:00+00:00",
      "venue": "Skyline Terrace",
      "allocation": 200
    }
  ],
  "next_cursor": null
}
```

### get_event

Full event: description, artists, venue, announce and on-sale dates, ticket types and price tiers. Access: read. REST: `POST /api/v1/dice/get_event`.

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

Returns one event with its description, line-up, venue and dates, and every ticket type with its price tiers. Read it before changing prices, so your agent sees which tier is current.

Example response:

```json
{
  "event_id": "ev_48213",
  "name": "Club Night",
  "state": "approved",
  "currency": "USD",
  "venue": "The Warehouse",
  "start": "2026-11-14T22:00:00+00:00",
  "end": "2026-11-15T04:00:00+00:00",
  "artists": [
    "DJ Orla",
    "Kest"
  ],
  "announce_at": "2026-10-01T10:00:00+00:00",
  "on_sale_at": "2026-10-02T10:00:00+00:00",
  "ticket_types": [
    {
      "ticket_type_id": "8841273",
      "name": "Early bird",
      "price_tier_type": "allocation",
      "tiers": [
        {
          "id": "510922",
          "name": "Early bird",
          "price": 1500,
          "allocation": 100
        }
      ]
    }
  ]
}
```

### get_sales_summary

Tickets sold and face value, split by ticket type and sales channel. Access: read. REST: `POST /api/v1/dice/get_sales_summary`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `since` | datetime | no | Only orders placed after this time. |

Adds up the orders of one event: tickets sold and face value per ticket type and per sales channel (internet, door, free, external). Face value is in cents. Both splits add up to the totals. Set since to count only newer orders.

Example response:

```json
{
  "event_id": "ev_48213",
  "currency": "USD",
  "tickets_sold": 182,
  "face_value": 314000,
  "by_ticket_type": [
    {
      "ticket_type_id": "8841273",
      "name": "Early bird",
      "tickets": 100,
      "face_value": 150000
    },
    {
      "ticket_type_id": "8841290",
      "name": "General admission",
      "tickets": 82,
      "face_value": 164000
    }
  ],
  "by_channel": [
    {
      "channel": "internet",
      "tickets": 160,
      "face_value": 276000
    },
    {
      "channel": "door",
      "tickets": 22,
      "face_value": 38000
    }
  ]
}
```

### list_orders

Orders with time, quantity, sales channel, totals and promo code used. Access: read. REST: `POST /api/v1/dice/list_orders`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `sales_channel` | enum | no | internet, door, free or external. Default: all. |
| `since` | datetime | no | Only orders placed after this time. |
| `limit` | integer | no | 1 to 100. Default: 50. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists the orders of one event, newest first, with time, number of tickets, sales channel and total in cents. Use it when the summary is not enough. Pages hold up to 100 orders; pass next_cursor back as cursor.

Example response:

```json
{
  "orders": [
    {
      "order_id": "or_90412",
      "placed_at": "2026-10-09T18:22:00+00:00",
      "channel": "internet",
      "tickets": 2,
      "total": 3600,
      "promo_code": null
    },
    {
      "order_id": "or_90398",
      "placed_at": "2026-10-09T16:05:00+00:00",
      "channel": "internet",
      "tickets": 1,
      "total": 1800,
      "promo_code": "FRIENDS"
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjUwfQ"
}
```

### list_ticket_holders

Who holds a ticket now: name, ticket type and whether it was claimed. Access: read. REST: `POST /api/v1/dice/list_ticket_holders`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `ticket_type_id` | string | no | Only one ticket type. |
| `format` | enum | no | json or csv. Default: json. |
| `cursor` | string | no | Next page cursor from the previous call. |

Lists who holds a ticket for one event right now, so returned and transferred tickets are reflected. Filter by ticket type for a door list per type. Set format to csv to get a file your door team can open. Pages hold up to 100 rows; pass next_cursor back as cursor.

Example response:

```json
{
  "ticket_holders": [
    {
      "ticket_id": "tk_1182034",
      "name": "Sam Ortiz",
      "ticket_type": "Early bird",
      "claimed": true
    },
    {
      "ticket_id": "tk_1182035",
      "name": "Jo Marsh",
      "ticket_type": "General admission",
      "claimed": false
    }
  ],
  "next_cursor": null
}
```

### list_returns

Tickets returned by fans, with date, reason and the original order. Access: read. REST: `POST /api/v1/dice/list_returns`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | no | Only one event. Default: all events. |
| `since` | datetime | no | Only returns after this time. |

Lists tickets that fans returned, newest first, with the date, the reason and the order they came from. Leave event_id out to cover all your events. Set since to see only the latest returns.

Example response:

```json
{
  "returns": [
    {
      "return_id": "rt_3301",
      "event_id": "ev_48213",
      "returned_at": "2026-10-08T12:40:00+00:00",
      "reason": "Can't make it",
      "order_id": "or_90102"
    }
  ]
}
```

### list_transfers

Tickets passed from one fan to another, with date and orders. Access: read. REST: `POST /api/v1/dice/list_transfers`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | no | Only one event. Default: all events. |
| `since` | datetime | no | Only transfers after this time. |

Lists tickets that fans passed to another fan, newest first, with the date and the orders involved. Leave event_id out to cover all your events. Set since to see only the latest transfers.

Example response:

```json
{
  "transfers": [
    {
      "transfer_id": "tf_7710",
      "event_id": "ev_48213",
      "transferred_at": "2026-10-09T09:15:00+00:00",
      "from_order_id": "or_90102",
      "to_order_id": "or_90415"
    }
  ]
}
```

### create_event

New event as a draft in MIO. Fans see nothing until you submit it and DICE approves it. Access: write. REST: `POST /api/v1/dice/create_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `name` | string | yes | Event name. |
| `venue` | string | yes | Venue name or ID from one of your past events. |
| `start` | datetime | yes | ISO 8601 with time zone. |
| `end` | datetime | yes | ISO 8601 with time zone. |
| `description` | string | no | Event description shown to fans. |
| `artists` | string[] | no | Line-up, headliner first. |
| `currency` | string | no | ISO code, e.g. USD, GBP, EUR. Default: your account currency. |
| `announce_at` | datetime | no | When the event appears on DICE. |
| `on_sale_at` | datetime | no | When tickets go on sale. |

Saves a new event as a draft in MIO. Fans see nothing until you submit it with submit_event and DICE approves it. Venue is a name or an ID from one of your past events. Add ticket types with add_ticket_type. create_event reaches no one, so it runs without asking first.

Example response:

```json
{
  "event_id": "ev_48501",
  "name": "Club Night",
  "state": "draft",
  "venue": "The Warehouse",
  "start": "2026-11-14T22:00:00+00:00",
  "end": "2026-11-15T04:00:00+00:00",
  "artists": [
    "DJ Orla",
    "Kest"
  ],
  "currency": "USD"
}
```

### add_ticket_type

Add a ticket type to an event, with price, allocation and optional door price. Access: write, asks the user first. REST: `POST /api/v1/dice/add_ticket_type`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `name` | string | yes | e.g. Early bird, General admission. |
| `price` | integer | yes | Face value in cents. 0 for a free ticket. |
| `allocation` | integer | yes | Number of tickets. |
| `description` | string | no | Shown to fans under the name. |
| `door_sales_price` | integer | no | Price at the door in cents. |

Adds a ticket type to an event with its face value in cents, allocation and an optional door price. A price of 0 makes a free ticket. On an event fans can already buy from, it changes what they can buy. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "ticket_type_id": "8841290",
  "event_id": "ev_48213",
  "name": "General admission",
  "price": 2000,
  "allocation": 250,
  "door_sales_price": 2500
}
```

### add_price_tier

Add a release to a ticket type that moves on after an allocation sells out or at a set time. Access: write, asks the user first. REST: `POST /api/v1/dice/add_price_tier`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `ticket_type_id` | string | yes | Ticket type ID from get_event. |
| `name` | string | yes | e.g. Second release. |
| `price` | integer | yes | Face value in cents. |
| `allocation` | integer | no | Tickets in this tier, for allocation-based tiers. |
| `time` | datetime | no | When the tier switches, for time-based tiers. |

Adds a price tier to a ticket type. A tier takes over after the earlier tier's allocation sells out (pass allocation) or at a set time (pass time). Price is in cents. The response lists all tiers of the ticket type in order. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "ticket_type_id": "8841273",
  "price_tier_type": "allocation",
  "tiers": [
    {
      "id": "510922",
      "name": "Early bird",
      "price": 1500,
      "allocation": 100
    },
    {
      "id": "510987",
      "name": "Second release",
      "price": 1800,
      "allocation": 150
    }
  ]
}
```

### update_ticket_type

Change the name, price, allocation or door price of a ticket type, or archive it to stop sales. Access: write, asks the user first. REST: `POST /api/v1/dice/update_ticket_type`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `ticket_type_id` | string | yes | Ticket type ID from get_event. |
| `fields` | object | yes | Any of name, description, price, allocation, door_sales_price, archived. |

Changes a ticket type: name, description, price, allocation, door price, or archived to stop sales. Only the fields you pass change. Price and allocation changes affect what fans pay and what is left. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "ticket_type_id": "8841290",
  "name": "General admission",
  "price": 2200,
  "allocation": 250,
  "archived": false
}
```

### submit_event

Send a draft to DICE for review. Once approved it is announced and goes on sale on its dates. Access: write, asks the user first. REST: `POST /api/v1/dice/submit_event`.

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

Sends a draft to DICE for review. Under the MIO terms DICE decides at its sole discretion which events it promotes, so the event can be declined. Once approved, it is announced and goes on sale on its dates. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_48501",
  "state": "submitted"
}
```

### update_event

Change the date, times, venue, line-up or description of an event fans may already hold tickets for. Access: write, asks the user first. REST: `POST /api/v1/dice/update_event`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `fields` | object | yes | Any of name, start, end, venue, artists, description. |

Changes the name, times, venue, line-up or description of an event. Only the fields you pass change. Fans may already hold tickets, so tell them with message_attendees. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_48213",
  "state": "approved",
  "updated": [
    "start"
  ],
  "start": "2026-11-14T20:00:00+00:00"
}
```

### message_attendees

Send an operational message to ticket holders with MIO Connect, e.g. door times or entry info. Access: write, asks the user first. REST: `POST /api/v1/dice/message_attendees`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `event_id` | string | yes | Event ID from list_events. |
| `message` | string | yes | Event information only, e.g. door times. |

Sends one message to the ticket holders of an event with MIO Connect. Keep it to event information such as door times. It reaches every ticket holder at once and cannot be unsent. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_48213",
  "status": "sent",
  "recipients": 182,
  "sent_at": "2026-11-14T12:00:00+00:00"
}
```

### cancel_event

Cancel an event in MIO. Fans are told and refunds follow your DICE agreement. Access: write, asks the user first. REST: `POST /api/v1/dice/cancel_event`.

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

Cancels an event in MIO. Under the MIO terms, you are responsible for refunds due to customers when an event is cancelled or rescheduled. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "event_id": "ev_48213",
  "state": "cancelled"
}
```

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

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

### Connect DICE to your agent.

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

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

```
Every Monday, give me last week's DICE sales for every show on sale: tickets per ticket type, door and external sales apart, and the returns and transfers since last Monday.
```

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

```
curl https://cotlet.dev/api/v1/dice/add_price_tier \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ticket_type_id":"8841273","name":"Second release","price":1800,"allocation":150}'
```

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

```
{
  "ticket_type_id": "8841273",
  "price_tier_type": "allocation",
  "tiers": [
    {
      "id": "510922",
      "name": "Early bird",
      "price": 1500,
      "allocation": 100
    },
    {
      "id": "510987",
      "name": "Second release",
      "price": 1800,
      "allocation": 150
    }
  ]
}
```

## Why use Cotlet for DICE?

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

## Is there a DICE MCP server on GitHub?

Yes. Community MCP servers for DICE exist on GitHub, usually maintained by one person. They read your data through the official Ticket Holders API with your MIO token, so they cannot create or change events. You install and fix them yourself; Cotlet hosts and maintains a server that also writes, so our team keeps it working.

|  | GitHub MCP server | Cotlet |
|---|---|---|
| Setup | Generate an API token in MIO, install the server, add it to each MCP client | Request access, sign in to MIO once, add one MCP server or API key |
| What it does | Reads events, ticket holders, orders, returns and transfers | The same reads, plus drafts, ticket types, price tiers, event changes and attendee messages |
| When DICE changes | Stable while the documented API stays the same | Our team tests it daily and fixes it for you; failed calls are free |
| Your credentials | An API token in a file on your computer | Your MIO session, encrypted in an EU vault, revoked in one click; we never store your password |
| 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 DICE 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 DICE API cost?

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

**Do I need to be technical?**

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

Cotlet keeps your DICE 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 DICE API token?**

No. Cotlet works in your own MIO account and does not use the Ticket Holders API, which is for DICE partners and needs a token generated in MIO (checked 11 Oct 2026).

**Can my agent put an event on sale by itself?**

It can create a draft and submit it, but DICE reviews every submitted event and decides at its sole discretion whether to promote it, so the agent cannot force an event live.

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

No. Every call to add_ticket_type, add_price_tier, update_ticket_type, submit_event, update_event, message_attendees 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 runs without asking, because it sends nothing to anyone and one call undoes it.

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