🚲 Bike Share & London Public Transport MCP Server

Bike Share & London Public Transport MCP Server is an MCP server that gives Claude, ChatGPT, Cursor, VS Code and other AI agents two kinds of city transport data: bike share stations in about 800 cities, collected by the CityBikes project, and London public transport and roads from Transport for London open data. Its 11 read-only tools cover bike stations, line status, arrivals, trip planning, line routes and road disruptions.

Ask Claude "is the Victoria line running, and when is the next train at Brixton?" and it calls mobility_get_london_line_status and mobility_get_london_arrivals: the status with the reason for any delay, then the next trains with minutes to arrival and platform. In Paris, ask for the nearest bike share station with a free dock and get its live counts. Your Apify token is the only key you need.

Quick start

1. Copy your API token from Apify Console > Settings > API & Integrations.
2. Add https://mrbridge--urban-mobility-mcp.apify.actor/mcp to your AI client with the header Authorization: Bearer <token>. The Connect section below has a ready-made snippet for each client.
3. Ask a question such as "any delays on the Northern line?"

What this server exposes

This server gives an AI client 11 read-only tools over two public transport data sources. From CityBikes, a community project that collects bike share feeds in about 800 cities, it finds bike share networks by city, country or distance, reads the live bikes, e-bikes and free docks of a whole network, and lists the stations closest to a point that have a bike or a free dock. From the Transport for London Unified API it reads the live or planned status of London lines (Tube, Elizabeth line, DLR, London Overground, trams, buses), finds stops and stations by name or around a point, returns the next arrivals at a stop, plans journeys with times, changes, fares and step-free options, lists the stops of a line in order, and reports traffic status and disruptions on the roads TfL manages. No account or API key is needed to use it, and every answer names its source. This server is not affiliated with CityBikes, with the bike share operators or with Transport for London.

Tools

Tool	What it answers	Billed event
mobility_search_bike_networks	Search bike share networks	tool-read
mobility_get_bike_network_status	Get live bike share network status	tool-read
mobility_find_nearby_bike_stations	Find bike share stations near a point	tool-read
mobility_get_london_line_status	Get London line status	tool-read
mobility_search_london_stops	Search London stops and stations	tool-read
mobility_find_london_stops_nearby	Find London stops near a point	tool-read
mobility_get_london_arrivals	Get London live arrivals at a stop	tool-read
mobility_plan_london_journey	Plan a London public transport journey	tool-action
mobility_get_london_line_route	Get the stops of a London line	tool-read
mobility_get_london_road_status	Get London road status	tool-read
mobility_get_london_road_disruptions	Get London road disruptions	tool-read

mobility_search_bike_networks: Search bike share networks

Use this when you need to find which bike share systems CityBikes covers in a city, a country or near a point, and their network ids. Do not use for live bike or dock counts (use mobility_get_bike_network_status with the id found here) or for stations near a point (use mobility_find_nearby_bike_stations). Parameters: query (text matched against network name, id, city and operator, accents and case ignored, e.g. "barcelona"), country (ISO 3166-1 alpha-2 code, e.g. "DE"), latitude and longitude (together, sort the networks by distance from that point, e.g. 48.8566 and 2.3522), limit (1 to 50, default 20), offset, response_format ("concise" or "detailed"). Without any filter the whole list of about 800 networks is paged in name order.

Parameter	Type	Required	Example
query	string	no	"barcelona"
country	string	no	"FR"
latitude	number	no	48.8566
longitude	number	no	2.3522
limit	integer	no	20
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { networks[], next_tool, pagination, notes[], attribution }. Upstream: CityBikes. Cache: daily (1 day). Read-only.

mobility_get_bike_network_status: Get live bike share network status

Use this when you need live availability across one bike share network: total bikes, e-bikes and free docks, empty and full stations, and a page of stations with their counts. Do not use for finding a network id (use mobility_search_bike_networks) or for the stations closest to a point (use mobility_find_nearby_bike_stations). Parameters: network_id (required, CityBikes id, e.g. "velib"), station_query (filters stations by name, e.g. "bastille"), availability ("any" default, "bikes", "ebikes", "docks", "empty" or "full"), sort ("name" default, "most_bikes" or "most_docks"), limit (1 to 100, default 20), offset, response_format ("concise" or "detailed" with coordinates, update time, slots, renting and payment). Totals always cover the whole network. Data is refreshed every 30 seconds at most.

Parameter	Type	Required	Example
network_id	string	yes	"velib"
station_query	string	no	"bastille"
availability	"any" or "bikes" or "ebikes" or "docks" or "empty" or "full"	no	"bikes"
sort	"name" or "most_bikes" or "most_docks"	no	"most_bikes"
limit	integer	no	20
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { network, totals, matched_stations, stations[], pagination, notes[], attribution }. Upstream: CityBikes. Cache: live (30 seconds). Read-only.

mobility_find_nearby_bike_stations: Find bike share stations near a point

Use this when you need the closest bike share stations to a point, with live bikes, e-bikes and free docks, for example to pick up or return a bike. Do not use for a whole network overview (use mobility_get_bike_network_status) or for London Tube and bus stops (use mobility_find_london_stops_nearby). Parameters: latitude and longitude (required, e.g. 40.758 and -73.9855), radius_m (100 to 3000, default 500), need ("bike" default, "ebike", "dock" or "any"), network_id (optional CityBikes id, e.g. "citi-bike-nyc", otherwise the two nearest networks within 50 km are read), limit (1 to 50, default 10), offset, response_format ("concise" or "detailed" with coordinates and update time). Distances are straight lines, not walking routes.

Parameter	Type	Required	Example
latitude	number	yes	40.758
longitude	number	yes	-73.9855
radius_m	integer	no	500
need	"bike" or "ebike" or "dock" or "any"	no	"bike"
network_id	string	no	"velib"
limit	integer	no	10
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { origin, radius_m, networks_checked[], stations[], pagination, notes[], attribution }. Upstream: CityBikes. Cache: live (30 seconds). Read-only.

mobility_get_london_line_status: Get London line status

Use this when you need the live or planned service status of London lines: Tube, Elizabeth line, DLR, London Overground, trams, buses, with the reason for delays and closures. Do not use for next departures at a stop (use mobility_get_london_arrivals) or for roads (use mobility_get_london_road_status). Parameters: line_ids (1 to 20 line ids or names, e.g. ["northern", "Hammersmith & City", "73"]) or modes (tube, elizabeth-line, dlr, overground, tram, cable-car, river-bus, bus, national-rail, default the first five), not both. start_date and end_date (together, YYYY-MM-DD, at most 31 days apart, e.g. "2026-10-03" and "2026-10-04") give the planned status for that period, bus then needs line_ids. only_disrupted (default false), limit (1 to 100, default 50, at most 20 in detailed format), offset, response_format ("concise" or "detailed" with every status and its validity).

Parameter	Type	Required	Example
line_ids	array of string	no	["northern","victoria"]
modes	array of string	no	["tube","dlr"]
start_date	string	no	"2026-10-03"
end_date	string	no	"2026-10-04"
only_disrupted	boolean	no	false
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { period, summary, lines[], pagination, notes[], attribution }. Upstream: TfL Unified API. Cache: live (30 seconds). Read-only.

mobility_search_london_stops: Search London stops and stations

Use this when you need the id of a London station, stop or pier from its name or from a 5-digit bus stop code, for example before asking for arrivals or planning a journey. Each id comes with its kind: station, bus_stop, stop_group or hub. Do not use for stops around a point (use mobility_find_london_stops_nearby) or for bike share stations (use mobility_get_bike_network_status). Parameters: query (station or stop name, or a 5-digit bus stop code, e.g. "Oxford Circus" or "52001"), modes (optional filter: tube, elizabeth-line, dlr, overground, tram, cable-car, river-bus, bus, national-rail, e.g. ["tube"]), limit (1 to 50, default 10), offset, response_format ("concise" or "detailed" with the journey planner ICS id).

Parameter	Type	Required	Example
query	string	yes	"Oxford Circus"
modes	array of string	no	["tube"]
limit	integer	no	10
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { query, stops[], next_step, pagination, attribution }. Upstream: TfL Unified API. Cache: daily (1 day). Read-only.

mobility_find_london_stops_nearby: Find London stops near a point

Use this when you need the London bus stops, Tube, rail and DLR stations or piers closest to a point, with the lines they serve and, for bus stops, the stop letter and direction. Do not use for a stop known by name (use mobility_search_london_stops) or for bike share stations (use mobility_find_nearby_bike_stations). Parameters: latitude and longitude (required, e.g. 51.5074 and -0.1278), radius_m (50 to 2000, default 400), stop_kind ("all" default, "stations" or "bus_stops"), modes (optional filter, e.g. ["bus"]), limit (1 to 50, default 10), offset, response_format ("concise" or "detailed" with coordinates, stop type and SMS code). Covers the TfL area only.

Parameter	Type	Required	Example
latitude	number	yes	51.5074
longitude	number	yes	-0.1278
radius_m	integer	no	400
stop_kind	"all" or "stations" or "bus_stops"	no	"bus_stops"
modes	array of string	no	["bus"]
limit	integer	no	10
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { origin, stops[], next_step, pagination, attribution }. Upstream: TfL Unified API. Cache: daily (1 day). Read-only.

mobility_get_london_arrivals: Get London live arrivals at a stop

Use this when you need the next Tube trains, buses, DLR, Overground, Elizabeth line or tram services due at one London stop or station, with minutes to arrival, platform and destination. Do not use for finding a stop id (use mobility_search_london_stops or mobility_find_london_stops_nearby) or for whether a line runs normally (use mobility_get_london_line_status). Parameters: stop_id (required stop id, e.g. "940GZZLUOXC" for Oxford Circus Tube or "490008660N" for one bus stop), line_ids (optional filter, e.g. ["victoria"]), limit (1 to 50, default 20), offset, response_format ("concise" or "detailed" with direction, vehicle and current location). Predictions cover roughly the next 30 minutes. For buses use the id of the stop itself, as given by mobility_find_london_stops_nearby.

Parameter	Type	Required	Example
stop_id	string	yes	"940GZZLUOXC"
line_ids	array of string	no	["victoria"]
limit	integer	no	20
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { stop, lines_served[], arrivals[], pagination, notes[], attribution }. Upstream: TfL Unified API. Cache: live (30 seconds). Read-only.

mobility_plan_london_journey: Plan a London public transport journey

Use this when you need door-to-door public transport journeys in and around London (Tube, bus, rail, DLR, Overground, Elizabeth line, tram, river bus, walking) with times, changes, fares and legs. Do not use for live departures at one stop (use mobility_get_london_arrivals), for line disruptions (use mobility_get_london_line_status) or for journeys outside the TfL network. Parameters: from and to (required, coordinates "51.5308,-0.1238", a UK postcode "SW1A 2AA", a stop id "940GZZLUKSX" or a station name "Heathrow Terminal 5", names are resolved with the stop search), via (optional, same forms), date (YYYY-MM-DD, default today) and time (HH:MM, London time, default now), time_is ("depart" default or "arrive", arrive needs a time), preference ("fastest" default, "fewest_changes" or "least_walking"), modes (optional list, e.g. ["tube", "walking"]), step_free (default false, step-free to the platform), max_journeys (1 to 5, default 3), response_format ("concise" or "detailed" with instructions, distances and disruption texts).

Parameter	Type	Required	Example
from	string	yes	"Kings Cross St. Pancras"
to	string	yes	"Heathrow Terminal 5"
via	string	no	"Paddington"
date	string	no	"2026-09-29"
time	string	no	"08:30"
time_is	"depart" or "arrive"	no	"depart"
preference	"fastest" or "fewest_changes" or "least_walking"	no	"fastest"
modes	array of string	no	["tube","elizabeth-line"]
step_free	boolean	no	false
max_journeys	integer	no	3
response_format	"concise" or "detailed"	no	"concise"

Returns { from, to, via, journeys[], notes[], attribution }. Upstream: TfL Unified API. Cache: live (30 seconds). Read-only.

mobility_get_london_line_route: Get the stops of a London line

Use this when you need the stations or stops of one London line or bus route in travel order, with its branches, for example which stations the Victoria line calls at. Do not use for live status (use mobility_get_london_line_status) or for live arrivals (use mobility_get_london_arrivals). Parameters: line_id (required line id or name, e.g. "victoria", "Northern line" or "25"), direction ("outbound" default or "inbound"), service ("regular" default or "night"), response_format ("concise" gives each route as a list of stop names, "detailed" adds every station with id, zone and coordinates).

Parameter	Type	Required	Example
line_id	string	yes	"victoria"
direction	"outbound" or "inbound"	no	"outbound"
service	"regular" or "night"	no	"regular"
response_format	"concise" or "detailed"	no	"concise"

Returns { line, direction, service, routes[], routes_truncated, stations[], attribution }. Upstream: TfL Unified API. Cache: daily (1 day). Read-only.

mobility_get_london_road_status: Get London road status

Use this when you need the current traffic status of the main roads managed by TfL in London (A roads, the North and South Circular, the Blackwall Tunnel), each as good, moderate, serious or severe. Do not use for the individual incidents, roadworks and closures on those roads (use mobility_get_london_road_disruptions) or for public transport (use mobility_get_london_line_status). Parameters: road_ids (optional, 1 to 30 road ids or names, e.g. ["a406", "North Circular (A406)"], default every TfL road), response_format ("concise" or "detailed" with the period the status covers).

Parameter	Type	Required	Example
road_ids	array of string	no	["a406","a2"]
response_format	"concise" or "detailed"	no	"concise"

Returns { summary, roads[], attribution }. Upstream: TfL Unified API. Cache: intraday (5 minutes). Read-only.

mobility_get_london_road_disruptions: Get London road disruptions

Use this when you need the active incidents, roadworks, events and closures on the roads TfL manages in London, with severity, location, description and dates. Do not use for the overall status of a road (use mobility_get_london_road_status) or for public transport disruptions (use mobility_get_london_line_status). Parameters: road_ids (optional, 1 to 30 road ids or names, e.g. ["a2"], default every TfL road), severities (optional filter: Minimal, Moderate, Serious, Severe), closures_only (default false), limit (1 to 50, default 20, at most 20 in detailed format), offset, response_format ("concise" or "detailed" with the latest update and status). Results are sorted by severity, most severe first. Disruptions that close a road (flagged by TfL or listing a closed street) are always included whatever the severity filter.

Parameter	Type	Required	Example
road_ids	array of string	no	["a406","a2"]
severities	array of string	no	["Serious","Severe"]
closures_only	boolean	no	false
limit	integer	no	20
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { disruptions[], pagination, notes[], attribution }. Upstream: TfL Unified API. Cache: intraday (5 minutes). Read-only.

Connect

Endpoint (Streamable HTTP): https://mrbridge--urban-mobility-mcp.apify.actor/mcp

Every client authenticates with your Apify API token, found in Apify Console > Settings > API & Integrations. Clients that support custom headers send it as Authorization: Bearer <token>. The others use the ?token= URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

Claude Code

$claude mcp add --transport http urban-mobility "https://mrbridge--urban-mobility-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"

Cursor, VS Code and other JSON configurations

{
  "mcpServers": {
    "urban-mobility": {
      "type": "http",
      "url": "https://mrbridge--urban-mobility-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}

claude.ai and Claude Desktop

Add a custom connector with the URL https://mrbridge--urban-mobility-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN and no authentication. Prefilled link (replace the token placeholder before saving): add Bike Share & London Public Transport MCP Server to Claude.

ChatGPT (developer mode)

Settings > Apps > Create, URL https://mrbridge--urban-mobility-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

OpenAI Responses API

{
  "type": "mcp",
  "server_label": "urban_mobility",
  "server_url": "https://mrbridge--urban-mobility-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}

Add allowed_tools to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

Anthropic Messages API

{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--urban-mobility-mcp.apify.actor/mcp",
      "name": "urban-mobility",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "urban-mobility"
    }
  ]
}

Send the beta header anthropic-beta: mcp-client-2025-11-20.

One-click OAuth alternative

https://mcp.apify.com/?tools=mrbridge/urban-mobility-mcp connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

Cost control

Each Standby run has a spending limit (maxTotalChargeUsd). When a call uses the last of it, the result is still returned, and later calls in that run answer CHARGE_LIMIT_REACHED until the limit is raised.

Why use Bike Share & London Public Transport MCP Server

• Bikes and transit in one server. Bikes, e-bikes and free docks in about 800 cities, plus London line status, arrivals, trip plans and roads.
• Answers from a location. Give coordinates and get the closest bike stations with a bike or a free dock, or the closest London stops with their lines and direction.
• London trip planning. Times, changes, fares and a step-free option, plus planned closures over a date range.
• Plain-language inputs. Line names such as "Hammersmith & City", road names such as "North Circular", station names as start and end points.
• Credits handled. Every answer carries the attribution its source asks for, including the CityBikes link and "Powered by TfL Open Data".

Pricing (Pay-per-Event)

Bike Share & London Public Transport MCP Server uses pay-per-event pricing. Each successful call to mobility_plan_london_journey is one tool-action event at $0.01, and each successful call to any other tool is one tool-read event at $0.005, so 1,000 reads cost $5 in events. These are the prices on the Apify Free plan, and the discounts of paid plans lower them. Apify also bills its standard apify-actor-start event when a Standby run starts, and you pay the platform usage of your own Standby run on top of the events, as explained below. Calls that end in an error carry no event charge. See the Pricing tab for the price on your Apify plan.

Event	Charged when	Price
apify-actor-start	run start (platform default)	see the Store page
tool-read (primary event)	each successful read tool call	see the Store page
tool-action	each successful call of a detailed or computed tool	see the Store page

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout. The Apify pay-per-event documentation says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

Limits, caveats and attribution

• Attribution. Every answer carries an attribution block: the provider, the source line its terms ask for, the terms URL and the notices below. Keep it when you show or reuse the data.
• CityBikes. Station data comes from each operator's public feed through CityBikes, which collects it with PyBikes. How fresh it is depends on the operator: the network status answer gives the newest and oldest station update and warns when the newest one is over an hour old. Some operators do not report e-bikes or free docks separately, and those fields are then null. Dockless networks that only publish free-floating vehicles are not listed. CityBikes allows 300 requests per hour for everyone using the public API, so this server caches the network list for a day and station data for 30 seconds. Under heavy use a call can still meet UPSTREAM_RATE_LIMITED.
• Transport for London. Coverage is Greater London and the rail services TfL publishes. Arrival predictions cover roughly the next 30 minutes, and journey plans follow the TfL journey planner, with times in London local time and fares as TfL returns them. Place names given to the journey planner are matched to the first stop found by the TfL stop search, and the answer names the stop it used. A planned status lists the works TfL has published for the period. Live incidents can still happen. Line status and arrivals are cached for 30 seconds, road status and disruptions for 5 minutes, stop searches and line routes for a day.
• Rate limits. TfL allows 50 requests per minute without a key and 500 with the owner's free key. This server keeps to half of each limit, shared by every user of the Actor.
• Not covered. Deutsche Bahn and other German timetables are not included: the Deutsche Bahn terms of use do not allow commercial reuse of the data of its apps.

Data terms

By using this server you agree to use the data it returns in line with the terms of each source, and to pass the same obligations on to anyone you share the data with.

• CityBikes: Terms of Service. If you publish or display the data in an app or a website, say clearly that it comes from CityBikes, with a link to https://citybik.es.
• Transport for London: Transport Data Service terms and design and branding guidelines. Show "Powered by TfL Open Data", "Contains OS data © Crown copyright and database rights 2016" and "Geomni UK Map data © and database rights [2019]" wherever you publish the data. Do not use the TfL roundel, logos or trademarks, and do not suggest that TfL endorses your product.

The fee for this server pays for the service (hosting, caching, normalisation), not for a licence on the data.

Use cases

• Commute assistant. "Any delays on the Northern line this morning?" or "When is the next 38 bus at Angel?"
• Getting around London. "Step-free route from Paddington to Greenwich, with the fare."
• Weekend planning. "Which lines have planned closures on Saturday and Sunday?"
• Bike share trips. "Nearest station with an e-bike near the Louvre" in any of the cities CityBikes covers.
• Drivers and couriers. "Is the Blackwall Tunnel moving, and what roadworks are on the North Circular?"
• Hotel and travel concierges. Let an assistant tell guests how to reach a venue by bike, Tube or bus.

London only for public transport and roads. Bike share data comes from each operator's feed, so freshness and detail vary by city.

FAQ

Why is the first call slower?

The server runs in Apify Standby mode. When no request comes in for a while, the run stops at its idle timeout, and the next call starts a new one. That cold start took about 5 seconds in the last platform test. Calls made while the server is warm skip the delay.

Which cities are covered?

Bike share: about 800 cities worldwide, through CityBikes. Ask mobility_search_bike_networks for a city or a country to see what exists there. Public transport and road status: Greater London only. German timetables are not included.

How fresh is the data?

Bike station counts are cached for 30 seconds and depend on each operator's feed. The network status answer says how old the newest and oldest station updates are. London line status and arrivals are cached for 30 seconds, and arrival predictions reach about 30 minutes ahead.

Why do some calls answer UPSTREAM_RATE_LIMITED?

CityBikes allows 300 requests per hour for everyone on its public API, and London data has its own quota. Both are shared by every user of this server. It keeps to half of each limit and caches answers, but heavy use can still meet a temporary UPSTREAM_RATE_LIMITED. Those calls carry no event charge.

Can I show the data in my own app?

Yes, with the credits the sources ask for: a link to https://citybik.es for bike share data, and "Powered by TfL Open Data" with the Ordnance Survey and Geomni statements for London data. Do not use the TfL roundel or logos. The Data terms section above has the details.

Is this an official Transport for London service?

No. It is an independent server, not affiliated with or endorsed by Transport for London, CityBikes or the bike share operators.

Your feedback

Found a bug or a wrong answer? Open an issue on the Issues tab. Bike Share & London Public Transport MCP Server is built by MrBridge. More servers are listed in the MCP server catalogue, and more tools and data studies are at mr-bridge.com.

Changelog

• 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
• 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
• 0.1.2: pricing events tool-read and tool-action. A London journey plan (mobility_plan_london_journey) bills one tool-action event, every other tool one tool-read event
• 0.1.1: server name aligned with the Store title (connector name and connection page). The endpoint and the tools do not change.
• 0.1.0: initial build (private, unpublished)