swisstrip-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@swisstrip-mcpshow me train schedules from Zurich to Bern tomorrow at 8am"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
swisstrip-mcp
The canonical SwissTrip MCP client. Connects AI assistants to Swiss Federal Railways (SBB / CFF / FFS) data: train schedules, station search, ticket prices, and direct ticket purchase links.
Backed by SwissTrip's hosted MCP service at https://mcp.swisstrip.app/mcp. Independent third-party implementation; not the official SBB MCP.
Install
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"swisstrip": {
"command": "npx",
"args": ["-y", "swisstrip-mcp"]
}
}
}Cursor
Add to ~/.cursor/mcp.json:
{
"mcpServers": {
"swisstrip": {
"command": "npx",
"args": ["-y", "swisstrip-mcp"]
}
}
}Gemini CLI / Continue / other stdio MCP clients
Same pattern: command: npx, args: ["-y", "swisstrip-mcp"].
ChatGPT (Plus / Pro / Business / Enterprise with Developer Mode)
No install required. Add a custom connector pointing at:
https://mcp.swisstrip.app/mcpRelated MCP server: swiss-rail-mcp
Tools
search_stations— find Swiss stations, addresses, and points of interestsearch_connections— train schedules between two stationsget_trip_details— detailed trip with all intermediate stopsget_more_connections— earlier or later trains for a previous searchget_prices— ticket prices with Halbtax / GA / Sparbillet discountsget_ticket_link— direct purchase link to SBB.ch
Languages
Tool descriptions and natural-language responses available in 9 languages: English, German, French, Italian, Spanish, Portuguese, Dutch, Polish, Russian.
Optional configuration
Environment variable | Purpose |
| Override the hosted server URL. Default: |
| Same as above (legacy name, still supported). |
Aliases (also published, all spawn this canonical package)
The following npm packages are brand-protective aliases that spawn swisstrip-mcp:
swisstrip,swisstrip-ai,swisstrip-server— SwissTrip-brandedsbb-mcp,sbb-mcp-official,sbb-cff-ffs-mcp— SBB-themed (may transfer to SBB AG on request)swiss-rail-mcp,swiss-railways-mcp,swiss-train-mcp— generic descriptive
Recommended: install swisstrip-mcp directly. The aliases exist for discoverability and brand protection.
License
Proprietary. See LICENSE. © 2026 SwissTrip.
For commercial licensing inquiries: fabsforward2@gmail.com.
Available Tools
6 toolsget_more_connectionsGet More ConnectionsARead-onlyIdempotentInspect
Load earlier or later train connections for a previous search. Use the collection ID from search_connections results.
| Name | Required | Description | Default |
|---|---|---|---|
| direction | Yes | "next" for later trains, "previous" for earlier trains | |
| collection_id | Yes | Collection ID from search_connections results |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description ('load earlier or later train connections') is consistent with these hints but does not add additional behavioral context beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler. The first sentence states the primary action, and the second provides a critical usage hint. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, but the description does not explain what the response looks like (e.g., same format as search_connections). However, given the simple pagination use case and rich annotations, the description is mostly complete. Minor gap: no mention of output format or pagination behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so baseline is 3. The description adds practical context: collection_id comes from a prior search, and direction selects earlier/later. This adds value beyond the schema definition by clarifying usage flow.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool loads earlier/later train connections from a previous search, using a collection ID. It specifies the verb 'load', resource 'train connections', and distinguishes from sibling tools like search_connections that perform initial searches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use the collection ID from search_connections results, providing clear context for when to use. It does not explicitly exclude alternative scenarios or mention when not to use, but the context is sufficient for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pricesGet PricesARead-onlyIdempotentInspect
Get ticket prices in CHF for one or more train connections. Supports Half-Fare card (Halbtax) and GA travelcard discounts. Up to 10 trip_ids per call — batch them in a single request rather than calling once per connection. Use trip_ids from a recent search_connections result; do not invent IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| trip_ids | Yes | Trip IDs from search_connections results | |
| traveler_type | No | Traveler type | ADULT |
| reduction_card | No | Swiss reduction card: HALF_FARE (Halbtax), GA (General Abonnement), or NONE | HALF_FARE |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only and idempotent. Description adds that it supports specific discount cards and batching limits. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tightly packed sentences: purpose, discount support, batching instruction, and source requirement. No wasted words, all relevant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Sufficient for a simple tool with schema coverage and annotations. Doesn't describe return format, but the tool is straightforward (prices). Minor gap but adequately complete for selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% with basic descriptions. The description adds critical context for trip_ids (source and validity) and reinforces discount card meanings. Adds some value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Explicitly states it gets ticket prices in CHF for train connections, specifies discount support, and distinguishes from siblings like search_connections (which doesn't return prices) and get_trip_details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clearly advises to use trip_ids from search_connections, to avoid inventing IDs, and to batch up to 10 per call. However, it doesn't explicitly state when to use alternatives, but the context is clear given sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_ticket_linkGet Ticket LinkARead-onlyInspect
Get a direct purchase link to buy a train ticket on SBB.ch. Only call this when the user wants to buy a specific ticket. On mobile with SBB app installed, opens directly in the app with Halbtax/GA applied automatically.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | Travel date YYYY-MM-DD | |
| time | Yes | Departure time HH:MM | |
| to_id | Yes | Destination station ID (e.g. "8507000") | |
| from_id | Yes | Origin station ID (e.g. "8503000") | |
| to_name | Yes | Destination station name (e.g. "Bern") | |
| trip_id | Yes | Trip ID to purchase | |
| from_name | Yes | Origin station name (e.g. "Zürich HB") | |
| traveler_type | No | Traveler type | ADULT |
| reduction_card | No | Swiss reduction card: HALF_FARE (Halbtax), GA (General Abonnement), or NONE | HALF_FARE |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable behavioral context beyond annotations: 'On mobile with SBB app installed, opens directly in the app with Halbtax/GA applied automatically.' This discloses platform-specific behavior and default discounts. It aligns with annotations (readOnlyHint=true, no destruction). No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with three sentences, each serving a clear purpose: first states the core function, second provides usage guideline, third adds mobile behavior. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 9 parameters and no output schema, the description is fairly complete. It explains the output (a direct purchase link) and special mobile behavior. However, it lacks information about error handling, or what the link looks like, which could be useful. Still, it covers the essential aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add significant meaning beyond the schema; it mentions the link is for a specific ticket but does not explain how parameters like reduction_card affect the generated link. The description is adequate but not enriching.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get a direct purchase link to buy a train ticket on SBB.ch.' It specifies the verb 'Get' and resource 'direct purchase link', and distinguishes from siblings by stating 'Only call this when the user wants to buy a specific ticket.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Only call this when the user wants to buy a specific ticket.' This provides clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, though the sibling tool names (e.g., get_prices, get_trip_details) imply such distinctions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trip_detailsGet Trip DetailsARead-onlyIdempotentInspect
Get detailed information about a specific train connection including all intermediate stops, platforms, and occupancy. Use a trip ID from search_connections results.
| Name | Required | Description | Default |
|---|---|---|---|
| trip_id | Yes | Trip ID from search_connections results |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly and idempotent. The description adds specific behaviors: showing intermediate stops, platforms, and occupancy. This enriches the agent's understanding beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences: first covers purpose and content, second covers prerequisite. No unnecessary words. Front-loaded with the key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While there is no output schema, the description lists key return elements (intermediate stops, platforms, occupancy). For a simple read-only tool with one parameter, this is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter trip_id, with the same prerequisite text as the tool description. The description adds no new semantic meaning beyond what is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get detailed information about a specific train connection' and lists contents (intermediate stops, platforms, occupancy). It distinguishes from siblings like search_connections by specifying a single trip ID.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use a trip ID from search_connections results,' providing a clear prerequisite. While it doesn't list when not to use, the context and sibling list imply this is for detailed view after search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_connectionsSearch ConnectionsARead-onlyIdempotentInspect
Find train connections between two Swiss stations. Accepts station names directly (e.g. "Zürich HB", "Bern") or UIC IDs — name resolution happens internally. Returns live schedules with departure/arrival times, duration, transfers, and trip IDs for downstream pricing/details/ticket calls. Live data: includes delays and cancellations for trains departing within 30 min.
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | Destination station name or ID (e.g. "Bern" or "8507000") | |
| date | No | Travel date in YYYY-MM-DD format (default: today) | |
| from | Yes | Origin station name or ID (e.g. "Zurich HB" or "8503000") | |
| time | No | Time in HH:MM (Europe/Zurich local time, 24h). By default treated as DEPARTURE time. Default: now. | |
| arrival_time | No | Defaults to false (treat `time` as departure). Only set true when the user EXPLICITLY says they want to ARRIVE by a specific time ("I need to be in Bern by 9am", "arriving at 14:00"). For loose phrases like "around 9am", "morning", or "tomorrow at 9", leave this false — those mean departure time. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating a safe, non-destructive read. The description adds valuable behavioral context: 'name resolution happens internally' (explaining input handling), 'Live data: includes delays and cancellations for trains departing within 30 min' (scope of real-time data), and the nuanced behavior of the 'arrival_time' parameter (defaults to departure time, only set true for explicit arrival requests). No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph but is well-structured and front-loaded with the main purpose. Every sentence adds value: input acceptance, return contents, live data scope, and parameter clarification. It is not overly long, though a slight restructuring could improve scanability. Overall, it is appropriately sized for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no output schema, and sibling tools, the description is remarkably complete. It explains input formats, what is returned (times, duration, transfers, trip IDs), live data scope, and how to use parameters like 'arrival_time' correctly. It also hints at downstream usage (trip IDs for pricing/details/tickets). The description fully covers the tool's behavior without needing an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are described in the input schema. The description adds significant semantic value beyond the schema: it clarifies that station names can be used directly (not just IDs), explains the 'arrival_time' parameter's default and when to override, and specifies that 'time' is treated as departure by default. This extra guidance is helpful for correct use.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Find train connections between two Swiss stations', using a specific verb ('Find') and resource ('train connections'). It further specifies input flexibility (station names or UIC IDs) and output details (live schedules, delays, cancellations). This effectively differentiates from sibling tools like 'search_stations' (station search only) and 'get_trip_details' (details for a specific trip).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it accepts station names or IDs, returns live schedules, and mentions that live data includes delays for departures within 30 min. It also explains the behavior of the 'arrival_time' parameter and when to set it to true. However, it does not explicitly state when not to use this tool or recommend alternatives (e.g., 'get_more_connections' for pagination), so it misses some explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_stationsSearch StationsARead-onlyIdempotentInspect
Search for Swiss train stations, addresses, or points of interest by name. Returns UIC station IDs (e.g. "8503000" for Zürich HB) used by the other tools. Note: search_connections accepts station names directly, so this tool is only needed when the user explicitly asks for station info or when you need disambiguation between multiple matches.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results | |
| query | Yes | Station name to search for (e.g. "Zurich", "Bern", "Interlaken") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by specifying the format of returned IDs (e.g., '8503000') and the context of use. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. Purpose is front-loaded, and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and simple parameters, the description is adequate. It explains return format and usage context. Minor gaps like pagination or empty results handling are acceptable for a simple search.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline 3. Description provides examples ('Zurich', 'Bern') but no additional semantics beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches for Swiss train stations, addresses, or POIs by name and returns UIC IDs. It distinguishes itself from 'search_connections' by explaining when this tool is needed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says the tool is only needed when the user asks for station info or needs disambiguation, and notes that 'search_connections' accepts names directly, providing clear when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.6.3- First observed
get_more_connections - First observed
get_prices - First observed
get_ticket_link - First observed
get_trip_details - First observed
search_connections - First observed
search_stations
TDQS
Each tool has a clearly distinct purpose: station search, connection search, trip details, pagination, pricing, and ticket purchase. No overlap or ambiguity between them.
All tools follow a consistent verb_noun pattern (search_* for queries, get_* for retrievals) with clear and predictable names.
6 tools is well-scoped for a Swiss railway information and ticket purchase server, covering essential operations without excess.
The tool set covers the full user journey: station lookup, connection search, details, pagination, pricing, and purchase link. No obvious gaps given the domain.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Swiss Transport MCP — wraps Transport Open Data API (free, no auth)
Swiss weather data for AI assistants — forecasts, measurements, stations, pollen.
The Ferryhopper MCP server is a connector for LLMs and AI Agents in maritime travel that exposes ferry routes, schedules, and booking options. It enables AI assistants to search ports and connections across 33 countries and 190+ ferry operators, provide real-time ferry itineraries with indicative prices, and assist users with planning island-hopping or multi-leg journeys by processing natural language queries about ferry times, passenger counts, and travel durations.
Swiss federal law (Fedlex) and political data (LINDAS) for agents, every answer with sources
Related MCP Servers
- AlicenseAqualityFmaintenanceIndependent MCP client by swsistrip for Swiss Federal Railways (SBB/CFF/FFS) — all schedules, prices, ticket links via SBB's official SMAPI.983-
- AlicenseAqualityDmaintenanceA zero-authentication MCP server for Swiss public transport, enabling users to query train connections, disruptions, station facilities, and plan journeys using natural language.12MIT
- FlicenseNot gradedqualityDmaintenanceEnables querying Swiss public transport (trains, buses, trams, boats) for stations, connections, and station boards via the opendata.ch API.-
- AlicenseNot gradedqualityCmaintenanceProvides real-time Belgian rail (SNCB/NMBS) data via the iRail API, enabling AI agents to query train schedules and live information.5MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Fabsbags/swisstrip-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server