Lime APIdata.lime.bike ↗
Access real-time Lime bike and scooter locations, station status, and system metadata across multiple cities via GBFS-compliant endpoints.
What is the Lime API?
This API exposes 5 GBFS-compliant endpoints for Lime's micromobility network, covering vehicle locations, station status, and system metadata across dozens of regions. The get_free_bike_status endpoint returns per-vehicle coordinates, reservation state, disabled state, and vehicle type for every available bike or scooter in a given region in real time. All endpoints accept a region parameter and return standardized GBFS fields including last_updated, ttl, and versioned data objects.
curl -X GET 'https://api.parse.bot/scraper/821870f9-1a42-4a64-bf0c-86e2253358ba/get_gbfs_discovery?region=washington_dc' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace data-lime-bike-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.lime_bike_gbfs_api import Lime
lime = Lime()
# Get a region by name (constructible)
dc = lime.region("washington_dc")
# Fetch system information
info = dc.system_info()
print(info.last_updated, info.version)
print(info.data.name, info.data.timezone)
# Get real-time vehicle locations
vehicles = dc.vehicle_status()
print(vehicles.last_updated, vehicles.ttl)
for bike in vehicles.data.bikes:
print(bike.bike_id, bike.lat, bike.lon, bike.vehicle_type, bike.is_reserved)
# Check station status
status_feed = dc.station_status()
for station in status_feed.data.stations:
print(station.station_id, station.num_vehicles_available, station.is_renting)
# Get discovery feed
disc = dc.discovery()
for feed in disc.data.en.feeds:
print(feed.name, feed.url)
Get the GBFS auto-discovery feed for a specific region. Returns the list of available feed URLs (system_information, station_information, station_status, free_bike_status) with their endpoints. Use this to discover which feeds are available for a region before calling specific feed endpoints.
| Param | Type | Description |
|---|---|---|
| regionrequired | string | Lime region identifier (e.g. 'washington_dc', 'new_york', 'chicago'). |
{
"type": "object",
"fields": {
"ttl": "integer, seconds until next update",
"data": "object containing language-keyed feeds with name and url for each available feed",
"version": "string, GBFS version",
"last_updated": "integer, UNIX timestamp of last data update"
},
"sample": {
"data": {
"ttl": 0,
"data": {
"en": {
"feeds": [
{
"url": "https://data.lime.bike/api/partners/v1/gbfs/washington_dc/system_information",
"name": "system_information"
},
{
"url": "https://data.lime.bike/api/partners/v1/gbfs/washington_dc/station_information",
"name": "station_information"
},
{
"url": "https://data.lime.bike/api/partners/v1/gbfs/washington_dc/station_status",
"name": "station_status"
},
{
"url": "https://data.lime.bike/api/partners/v1/gbfs/washington_dc/free_bike_status",
"name": "free_bike_status"
}
]
}
},
"version": "1.0",
"last_updated": 1781131157
},
"status": "success"
}
}About the Lime API
Vehicle and Station Data
The get_free_bike_status endpoint is the core feed for real-time vehicle tracking. For each vehicle in the bikes array it returns bike_id, lat, lon, is_reserved, is_disabled, and vehicle_type. Where available, rental_uris are included per vehicle, allowing deep-link integration with rental flows. The region parameter accepts identifiers like washington_dc, new_york, or chicago.
Station data comes in two feeds. get_station_information returns the static record for each logical station — station_id, name, lat, lon — while get_station_status provides the live operational view: num_vehicles_available, num_docks_available, is_installed, is_renting, and is_returning. Because Lime operates a dockless fleet, most regions surface a single virtual station rather than a physical dock network.
System Metadata and Discovery
get_system_information returns static regional metadata: system_id, language, name, timezone, license_url, and attribution_organization_name. This is useful for populating UI labels, respecting license attribution, and confirming timezone context when interpreting last_updated timestamps.
The get_gbfs_discovery endpoint returns the canonical list of available feed URLs for a given region, keyed by language. This is the standard GBFS auto-discovery pattern — it tells you which of the other feeds are actually published for that region before you query them individually. Every response across all endpoints includes a ttl field (seconds until next refresh) and a last_updated UNIX timestamp so callers can schedule polling efficiently.
The Lime API is a managed, monitored endpoint for data.lime.bike — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when data.lime.bike changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official data.lime.bike API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Map all available Lime scooters and bikes near a location using
lat/lonfromget_free_bike_status - Filter out reserved or disabled vehicles using
is_reservedandis_disabledflags before surfacing results to users - Build a multi-city micromobility dashboard by iterating over region identifiers and aggregating
num_vehicles_availablefromget_station_status - Attribute map data correctly by pulling
attribution_organization_nameandlicense_urlfromget_system_information - Check which GBFS feeds are active for a new region before querying vehicle or station endpoints, using
get_gbfs_discovery - Track fleet utilization over time by polling
get_free_bike_statusper region and recording vehicle counts at intervals - Integrate deep-link rental flows into a mobility app using
rental_urisreturned per vehicle inget_free_bike_status
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Lime publish an official developer API?+
What does `get_free_bike_status` return and how granular is the vehicle data?+
bike_id, precise lat/lon coordinates, a vehicle_type field, boolean flags for is_reserved and is_disabled, and optional rental_uris. Battery level, pricing, or trip history are not included in this feed.Does the API cover all Lime markets globally, or only certain regions?+
region parameter supports identifiers for cities where Lime publishes GBFS data, such as washington_dc, new_york, and chicago. Not every Lime market worldwide is guaranteed to have a published feed, and the set of available regions can change as Lime expands or suspends service. You can fork this API on Parse and revise it to add a region-listing endpoint that enumerates currently active regions.Are geofencing zones or service area boundaries available through this API?+
How fresh is the data returned by these endpoints?+
last_updated UNIX timestamp and a ttl integer (seconds until the next expected update). For get_free_bike_status, typical TTL values are in the range of 30–60 seconds, but this varies by region. Callers should respect the ttl to avoid fetching stale or redundant data.