# Omio API and MCP server

> Omio has no public API for your own account (checked 11 Oct 2026). Its affiliate programme lists a Search API for partners; booking, Your Bookings, changes and cancellations work only on omio.com and in the app.

Travel booking platform based in Berlin that searches, compares and books trains, buses, flights and ferries from many travel companies in one place.

## What is the Omio API?

Cotlet's Omio API exposes 10 endpoints for your own Omio account: search trips, get trip, list bookings, get booking, get tickets, get change options, get cancellation quote, book trip, change booking and cancel booking. The search_trips endpoint returns trains, buses, flights and ferries between two places on a date, with times, duration, changes, operator and price. Each endpoint takes simple JSON inputs like booking_id, date or passengers and works both as an MCP tool for agents and as a REST call for scripts.

- **Category:** [Travel](https://cotlet.dev/integrations/category/travel)
- **Endpoints:** 10 (7 read, 3 write)
- **Updated:** 2026-10-11

Omio has no public API for your own account (checked 11 Oct 2026). Cotlet is a hosted MCP server and REST API for Omio with 10 endpoints (7 read, 3 write): your AI agent signs in as you and does the work.

## Does Omio have an official API?

Omio has no public API for your own account (checked 11 Oct 2026). Its affiliate programme lists a Search API for partners; booking, Your Bookings, changes and cancellations work only on omio.com and in the app.

| Task | Omio official | Cotlet |
|---|---|---|
| Search trains, buses, flights and ferries | Partly: Search API for affiliate partners | Yes |
| Book a ticket on your account | No | Yes |
| List your bookings | No | Yes |
| Get your tickets | No | Yes |
| Change the departure of an exchangeable ticket | No | Yes |
| Cancel and see the refund amount | No | Yes |

Sources: [Omio Affiliate Programme](https://www.omio.com/affiliate), [Omio Help: change your departure date or time](https://help.omio.com/hc/en-us/articles/203726491-Can-I-change-my-departure-date-or-time), [Omio Help: cancel your ticket](https://help.omio.com/hc/en-us/articles/203646752-How-can-I-cancel-my-ticket), [Omio Terms of Use](https://www.omio.com/terms-of-use), [Omio Help: What is Omio Flex?](https://help.omio.com/hc/en-us/articles/24163906526236-What-is-Omio-Flex), [Omio Help: Are service fees refundable?](https://help.omio.com/hc/en-us/articles/13705522819228-Are-service-fees-refundable)

## For AI agents

```text
Omio has no public API for your own account (checked 11 Oct 2026). Its affiliate programme lists a Search API for partners; booking, Your Bookings, changes and cancellations work only on omio.com and in the app.
Cotlet provides a hosted MCP server and REST API for Omio: 10 tools (7 read, 3 write).
Access       Request access at https://cotlet.dev/app/signup?app=omio; we email the API key.

MCP server   https://cotlet.dev/mcp/v1
REST base    https://cotlet.dev/api/v1/omio
Auth         Authorization: Bearer <COTLET_API_KEY>. Listing endpoints and schemas needs no key; calling an endpoint needs one.
Tools        search_trips, get_trip, list_bookings, get_booking, get_tickets, get_change_options, get_cancellation_quote, book_trip, change_booking, cancel_booking
Confirm      book_trip, change_booking, cancel_booking (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/omio-api-mcp-server.md

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

## What can an AI agent do in Omio?

Cotlet is best for frequent travelers and travel assistants who want their AI agent to compare routes, book, change and cancel Omio tickets without running or fixing a server.

- **Compare train, bus and flight options**: "Compare train, bus and flight from Amsterdam to Munich next Thursday by price and travel time." → `search_trips`, `get_trip`
- **[Book the cheapest train or bus ticket](https://cotlet.dev/integrations/omio-api-mcp-server/book-cheapest-train-or-bus-ticket)**: "Book the cheapest refundable train from Amsterdam to Munich next Thursday, leaving after 9:00, and show me the total first." → `search_trips`, `get_trip`, `book_trip`, `list_bookings`
- **List upcoming trips and tickets** (runs: weekly): "List my upcoming Omio trips with times, operators and ticket status." → `list_bookings`, `get_booking`, `get_tickets`
- **[Change the date of a train ticket](https://cotlet.dev/integrations/omio-api-mcp-server/change-train-ticket-date)**: "My meeting moved to Friday. Move the Paris to Brussels train to Friday afternoon and tell me the fee first." → `list_bookings`, `get_booking`, `get_change_options`, `change_booking`
- **[Cancel a trip and see the refund](https://cotlet.dev/integrations/omio-api-mcp-server/cancel-trip-and-see-refund)**: "Cancel the Madrid to Valencia trip and tell me how much comes back." → `list_bookings`, `get_booking`, `get_cancellation_quote`, `cancel_booking`

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

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

## Tools

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

### search_trips

Trains, buses, flights and ferries between two places on a date, with times, duration, changes, operator and price. Access: read. REST: `POST /api/v1/omio/search_trips`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `from` | string | yes | Departure city or station, e.g. "Amsterdam". |
| `to` | string | yes | Arrival city or station. |
| `date` | date | yes | Departure date. |
| `return_date` | date | no | Return date for a round trip. |
| `passengers` | object | no | Count per passenger type, as in the Omio search form, e.g. { "adult": 2 }. Default: 1 adult. |
| `modes` | string[] | no | Any of train, bus, flight, ferry. Default: all. |
| `limit` | integer | no | 1 to 50. Default: 20. |

Searches Omio for one route and date. Each result has an operator, departure and arrival, duration, number of changes and the lowest price, so your agent can rank by price or travel time. Pass the trip_id of a result to get_trip for its fares.

Example response:

```json
{
  "trips": [
    {
      "trip_id": "trp_7f3k29qa",
      "mode": "train",
      "operator": "Deutsche Bahn",
      "departs": "2026-11-19T09:37:00+01:00",
      "arrives": "2026-11-19T17:05:00+01:00",
      "duration": "7h 28m",
      "changes": 1,
      "price": {
        "amount": 89,
        "currency": "EUR"
      }
    },
    {
      "trip_id": "trp_2c9d41bz",
      "mode": "bus",
      "operator": "FlixBus",
      "departs": "2026-11-19T10:15:00+01:00",
      "arrives": "2026-11-19T22:40:00+01:00",
      "duration": "12h 25m",
      "changes": 0,
      "price": {
        "amount": 54.99,
        "currency": "EUR"
      }
    },
    {
      "trip_id": "trp_5a1h88mx",
      "mode": "flight",
      "operator": "Lufthansa",
      "departs": "2026-11-19T11:20:00+01:00",
      "arrives": "2026-11-19T12:45:00+01:00",
      "duration": "1h 25m",
      "changes": 0,
      "price": {
        "amount": 142,
        "currency": "EUR"
      }
    }
  ]
}
```

### get_trip

Legs of one trip and its fare options with their conditions: exchangeable, refundable, Omio Flex. Access: read. REST: `POST /api/v1/omio/get_trip`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `trip_id` | string | yes | Trip ID from search_trips. |

Returns the legs of one search result and every fare option for it with the price and its conditions. Exchangeable decides whether you can change the ticket online later; refundable decides whether you can cancel it online. Pass fare_id to book_trip.

Example response:

```json
{
  "trip_id": "trp_7f3k29qa",
  "mode": "train",
  "operator": "Deutsche Bahn",
  "legs": [
    {
      "from": "Amsterdam Centraal",
      "to": "Köln Hbf",
      "departs": "2026-11-19T09:37:00+01:00",
      "arrives": "2026-11-19T12:19:00+01:00"
    },
    {
      "from": "Köln Hbf",
      "to": "München Hbf",
      "departs": "2026-11-19T12:49:00+01:00",
      "arrives": "2026-11-19T17:05:00+01:00"
    }
  ],
  "fares": [
    {
      "fare_id": "fare_2nd_refundable",
      "class": "2nd",
      "price": {
        "amount": 89,
        "currency": "EUR"
      },
      "exchangeable": false,
      "refundable": true,
      "omio_flex_available": true
    },
    {
      "fare_id": "fare_2nd_saver",
      "class": "2nd",
      "price": {
        "amount": 69,
        "currency": "EUR"
      },
      "exchangeable": false,
      "refundable": false,
      "omio_flex_available": true
    }
  ]
}
```

### list_bookings

Bookings from Your Bookings with route, date, operator and status. Access: read. REST: `POST /api/v1/omio/list_bookings`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `status` | enum | no | upcoming, past, cancelled or all. Default: upcoming. |
| `limit` | integer | no | 1 to 100. Default: 20. |

Reads Your Bookings and returns the trips on your account, upcoming by default, with route, departure, operator and status. Use booking_id with the other booking tools.

Example response:

```json
{
  "bookings": [
    {
      "booking_id": "OM58214793",
      "route": "Amsterdam Centraal to München Hbf",
      "departs": "2026-11-19T09:37:00+01:00",
      "operator": "Deutsche Bahn",
      "status": "confirmed"
    },
    {
      "booking_id": "OM61903278",
      "route": "Paris Gare du Nord to Bruxelles-Midi",
      "departs": "2026-11-18T09:13:00+01:00",
      "operator": "Eurostar",
      "status": "confirmed"
    },
    {
      "booking_id": "OM47720516",
      "route": "Madrid Atocha to València Joaquín Sorolla",
      "departs": "2026-12-03T08:20:00+01:00",
      "operator": "Renfe",
      "status": "confirmed"
    }
  ]
}
```

### get_booking

Journey, passengers, fare conditions, Omio Flex, confirmation status and price paid for one booking. Access: read. REST: `POST /api/v1/omio/get_booking`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |

Returns one booking: the journey, travelers, fare conditions (exchangeable, refundable), whether Omio Flex was added, the confirmation status and the price paid. Your agent reads the conditions to know whether it can still change or cancel the trip.

Example response:

```json
{
  "booking_id": "OM58214793",
  "status": "confirmed",
  "route": "Amsterdam Centraal to München Hbf",
  "departs": "2026-11-19T09:37:00+01:00",
  "operator": "Deutsche Bahn",
  "passengers": [
    {
      "first_name": "Alex",
      "last_name": "Example"
    }
  ],
  "fare": {
    "class": "2nd",
    "exchangeable": false,
    "refundable": true
  },
  "omio_flex": false,
  "total": {
    "amount": 92.98,
    "currency": "EUR"
  }
}
```

### get_tickets

The tickets Your Bookings shows for a confirmed booking. Access: read. REST: `POST /api/v1/omio/get_tickets`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |

Returns the ticket entries Your Bookings shows for a confirmed booking: the type of each ticket and a link to it where Omio offers one. A booking that is not confirmed has no tickets yet and the call says so.

Example response:

```json
{
  "booking_id": "OM58214793",
  "tickets": [
    {
      "passenger": "Alex Example",
      "type": "e-ticket",
      "url": "https://www.omio.com/mybookings"
    }
  ]
}
```

### get_change_options

For an exchangeable fare: the travel options for a new date and the fee for each. Access: read. REST: `POST /api/v1/omio/get_change_options`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |
| `date` | date | yes | New departure date. |

Returns the other travel options Omio offers for a new date on an exchangeable booking, each with the price difference and fee. Omio allows online changes only for exchangeable fares; for any other fare the call returns why the ticket cannot be changed online. Pass option_id to change_booking.

Example response:

```json
{
  "booking_id": "OM61903278",
  "options": [
    {
      "option_id": "opt_8841",
      "departs": "2026-11-20T15:13:00+01:00",
      "arrives": "2026-11-20T16:35:00+01:00",
      "price_difference": {
        "amount": 12,
        "currency": "EUR"
      },
      "fee": {
        "amount": 5,
        "currency": "EUR"
      },
      "total": {
        "amount": 17,
        "currency": "EUR"
      }
    },
    {
      "option_id": "opt_8842",
      "departs": "2026-11-20T17:43:00+01:00",
      "arrives": "2026-11-20T19:05:00+01:00",
      "price_difference": {
        "amount": 20,
        "currency": "EUR"
      },
      "fee": {
        "amount": 5,
        "currency": "EUR"
      },
      "total": {
        "amount": 25,
        "currency": "EUR"
      }
    }
  ]
}
```

### get_cancellation_quote

Refund amount and non-refundable fees before you cancel, or why the fare cannot be cancelled online. Access: read. REST: `POST /api/v1/omio/get_cancellation_quote`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |

Returns the refund Omio would pay if you cancelled now, with the service fee shown apart because Omio lists it as non-refundable. Omio allows online cancellation only for a refundable fare or a booking with Omio Flex; for other fares the call returns why it cannot be cancelled online. Nothing is cancelled.

Example response:

```json
{
  "booking_id": "OM47720516",
  "cancellable": true,
  "refund": {
    "amount": 42.5,
    "currency": "EUR"
  },
  "non_refundable": {
    "service_fee": 2.5,
    "currency": "EUR"
  },
  "paid": {
    "amount": 45,
    "currency": "EUR"
  }
}
```

### book_trip

Book a fare on your account. You confirm the total, including the service fee, before anything is paid. Access: write, asks the user first. REST: `POST /api/v1/omio/book_trip`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `trip_id` | string | yes | Trip ID from search_trips. |
| `fare_id` | string | yes | Fare option from get_trip. |
| `passengers` | object[] | yes | One entry per traveler: first_name, last_name, and any extra detail the travel company asks for. |
| `seat_preference` | enum | no | window, aisle or any, where the travel company offers seat choice. Default: any. |
| `add_omio_flex` | boolean | no | Add Omio Flex to the booking. Default: false. |

Books the fare you pick from get_trip with Omio's checkout. The total includes Omio's service fee. If your bank asks you to approve the payment, the call returns a link for you to finish it; Cotlet never bypasses that step. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "OM58214793",
  "status": "confirmed",
  "route": "Amsterdam Centraal to München Hbf",
  "departs": "2026-11-19T09:37:00+01:00",
  "operator": "Deutsche Bahn",
  "total": {
    "amount": 92.98,
    "currency": "EUR",
    "fare": 89,
    "service_fee": 3.98
  }
}
```

### change_booking

Switch an exchangeable ticket to another departure. You confirm the fee first. Access: write, asks the user first. REST: `POST /api/v1/omio/change_booking`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |
| `option_id` | string | yes | Travel option from get_change_options. |

Switches an exchangeable ticket to the option you pick from get_change_options. The price difference and the fee are charged as shown there. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "OM61903278",
  "status": "changed",
  "departs": "2026-11-20T15:13:00+01:00",
  "charged": {
    "price_difference": 12,
    "fee": 5,
    "total": 17,
    "currency": "EUR"
  }
}
```

### cancel_booking

Cancel a refundable booking, or one with Omio Flex, and get the refund Omio quotes. Access: write, asks the user first. REST: `POST /api/v1/omio/cancel_booking`.

| Parameter | Type | Required | Description |
|---|---|---|---|
| `booking_id` | string | yes | Booking ID from list_bookings. |

Cancels one booking that Omio lets you cancel online: a refundable fare, or a booking with Omio Flex, which cancels through it. The refund is the amount from get_cancellation_quote. By default you confirm each call; you can switch that off for this tool.

Example response:

```json
{
  "booking_id": "OM47720516",
  "status": "cancelled",
  "refund": {
    "amount": 42.5,
    "currency": "EUR"
  },
  "non_refundable": {
    "service_fee": 2.5,
    "currency": "EUR"
  }
}
```

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

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

### Connect Omio to your agent.

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

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

```
Compare train, bus and flight from Amsterdam to Munich next Thursday by price and travel time.
```

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

```
curl https://cotlet.dev/api/v1/omio/book_trip \
  -H "Authorization: Bearer $COTLET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"trip_id":"trp_7f3k29qa","fare_id":"fare_2nd_refundable","passengers":[{"first_name":"Alex","last_name":"Example"}],"add_omio_flex":false}'
```

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

```
{
  "booking_id": "OM58214793",
  "status": "confirmed",
  "route": "Amsterdam Centraal to München Hbf",
  "departs": "2026-11-19T09:37:00+01:00",
  "operator": "Deutsche Bahn",
  "total": {
    "amount": 92.98,
    "currency": "EUR",
    "fare": 89,
    "service_fee": 3.98
  }
}
```

## Why use Cotlet for Omio?

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

## Is there a Omio MCP server on GitHub?

No Omio MCP server or Zapier app turned up (checked 11 Oct 2026). Hosted scrapers read public search results only, and the one listing for Omio is marked deprecated. So your own bookings are handled by hand, in the app or on omio.com. Cotlet gives your agent that account, hosted and maintained by our team.

|  | By hand | Cotlet |
|---|---|---|
| Setup | Open Omio, search each route and compare the results yourself | Request access, sign in to Omio once, add one MCP server or API key |
| Your bookings | Open Your Bookings and read each trip | Your agent lists them, with tickets, fare conditions and refund quotes |
| When Omio changes | You find the new button yourself | Our team tests it daily and fixes it for you; failed calls are free |
| Your Omio session | Stays in your browser or the app | Encrypted in an EU vault, limited to the actions you allow, revoked in one click |
| When the session expires | You sign in again | We keep it alive; if Omio logs you out, your agent gets a link to sign in again |
| Where it runs | Where you sit, when you have time | 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 Omio 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 Omio API cost?

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

**Do I need to be technical?**

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

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

**Can my agent cancel any Omio ticket?**

Only tickets Omio lets you cancel online: a refundable fare or a booking with Omio Flex. Omio shows the refund before you confirm, and get_cancellation_quote returns the same figure. Some rail fares, such as Advance tickets, can be exchanged but not cancelled.

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

No. Every call to book_trip, change_booking or cancel_booking waits for your OK by default. For scheduled automations you can switch confirmation off per tool in your dashboard, for example only for approvals.

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