CityBikes Scraper: Up to 1,000 Free Results a Month (2026)

Station availability data covers over 600 bike-sharing networks worldwide, delivering 10 network fields and 15 station fields including real-time free bikes, empty slots, and geographic coordinates. Free-plan users pay $5.00 per 1,000 results, which works out to $0.005 per record with no upfront key needed. This tool fits transport planners, urban researchers, and mobility app developers needing live system capacity metrics. It is not for teams seeking long-term historical archives, as the underlying API returns only current operational snapshots.

Try it: open CityBikes Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try CityBikes Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of CityBikes Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 100, so a first run returns at most 100 results and costs at most $0.50 in result charges. That is enough to see the real shape of the data before deciding anything.

CityBikes Scraper was last updated on 2026-06-11. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 728,502 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run CityBikes Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Result charges scale directly with the total records written to your dataset. The maxItems setting controls your maximum financial exposure per run, while includeStations determines whether a query returns single network overviews or hundreds of individual station records. To test your setup cheaply, run in byNetwork mode with includeStations set to true and cap maxItems at 10.

How do you run CityBikes Scraper from the API?

The schema marks 1 of its 6 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~citybikes-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"byCity","city":"London","includeStations":true,"maxItems":100}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "byCity",
  "city": "London",
  "includeStations": True,
  "maxItems": 100
}

run = client.actor("crawlerbros~citybikes-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "byCity",
  "city": "London",
  "includeStations": true,
  "maxItems": 100
}

const run = await client.actor('crawlerbros~citybikes-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which CityBikes Scraper inputs matter, and which can you skip?

The mode parameter controls whether the scraper queries the entire directory, a single city, a country code, or a specific network ID. For targeted operational data, set mode to byNetwork and specify your target networkId directly. Leave maxItems set low during initial testing to avoid fetching thousands of unwanted station records across large regional networks.

• mode (string): What to fetch from the CityBikes API. Default: "byCity".
• networkId (string): CityBikes network ID, e.g. 'santander-cycles', 'divvy', 'citi-bike-nyc'. Find IDs in listNetworks mode.
• city (string): City name to search for bike networks (e.g. 'London', 'Paris', 'New York').
• country (string): ISO 3166-1 alpha-2 country code (e.g. 'US', 'FR', 'GB', 'DE', 'JP').
• includeStations (boolean): Fetch station-level data for each network. If false, only network-level records are emitted. Default: true.
• maxItems (integer): Hard cap on total emitted records (networks + stations combined). Default: 100.

Fixed-choice controls: mode accepts listNetworks (all bike-sharing networks worldwide), byNetwork (By Network ID - all stations for a specific network), byCity (search networks by city name, then fetch stations), byCountry (fetch all networks for a country code, then get their stations).

What does CityBikes Scraper return?

Output records supply current capacity snapshots, containing freeBikes, emptySlots, totalSlots, and spatial coordinates for mapping active infrastructure. They do not contain user trip logs, individual rider routes, historical daily averages, or transaction records. Use these records for immediate capacity checks or store them sequentially to construct custom time-series databases.

Network record (recordType: "network")

• recordType (e.g. network)
• sourceUrl (e.g. http://api.citybik.es/v2/networks)
• scrapedAt (e.g. 2026-01-01T00:00:00+00:00)
• id (e.g. santander-cycles)
• name (e.g. Santander Cycles)
• city (e.g. London)
• country (e.g. GB)
• latitude (e.g. 51.511218)
• longitude (e.g. -0.119824)
• company

Station record (recordType: "station")

• recordType (e.g. station)
• sourceUrl (e.g. http://api.citybik.es/v2/networks/santander-c...)
• scrapedAt (e.g. 2026-01-01T00:00:00+00:00)
• networkId (e.g. santander-cycles)
• networkName (e.g. Santander Cycles)
• city (e.g. London)
• country (e.g. GB)
• stationId (e.g. 001420f03e8b4f08f1bcc9bdc0260651)
• stationName (e.g. Prince of Wales Drive, Battersea Park)
• latitude (e.g. 51.475154)
• longitude (e.g. -0.15917)
• freeBikes (e.g. 3)
• emptySlots (e.g. 18)
• totalSlots (e.g. 21)
• lastUpdated (e.g. 2026-01-01T13:41:48+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open CityBikes Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run in listNetworks mode first to verify API access and collect valid target network IDs globally.
2. Inspect the returned records to confirm recordType is network and note the target network id string.
3. Switch mode to byNetwork and set networkId to your chosen ID, such as santander-cycles.
4. Ensure includeStations is set to true to receive station-level availability records.
5. Set maxItems to a modest limit like 100 for your initial dry run to control platform charges.
6. Execute the run and check the output dataset for recordType station entries with numeric freeBikes and emptySlots values.
7. Verify the scrapedAt timestamp on returned records matches the expected runtime window.
8. Schedule recurring runs using the target network settings to build a longitudinal dataset.

How do you apply it? Three worked playbooks

These are CityBikes Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Urban mobility research

Outcome: Analyze bike-sharing coverage and capacity by city

Configure: mode="byCity", city="London", includeStations=true, maxItems=500

Working method: Start by setting city to your target municipality in byCity mode to return all matching networks and their associated stations. Compare totalSlots across stations to plot geographical station distribution and overall docking capacity. Verify that returned records include valid coordinates for mapping.

Deliverable: A dataset of network and station records containing spatial coordinates and total slot counts across the specified city.

Stop condition: Zero network records returned for a major city query or missing latitude/longitude coordinates on station records.

Use case 2: Availability monitoring

Outcome: Track station fill rates across a network

Configure: mode="byNetwork", networkId="santander-cycles", includeStations=true, maxItems=1000

Working method: Execute scheduled runs at regular intervals targeting a single networkId to capture real-time updates. Compare freeBikes against totalSlots for each station record across consecutive runs to calculate fill rates over time.

Deliverable: A timeseries dataset of station records capturing freeBikes and emptySlots across specified polling intervals.

Stop condition: The lastUpdated timestamp on returned station records fails to advance across multiple run intervals.

Use case 3: Fleet analytics

Outcome: Identify stations that are consistently full or empty

Configure: mode="byNetwork", networkId="citi-bike-nyc", includeStations=true, maxItems=2000

Working method: Aggregate station records over a multi-day observation window across peak and off-peak hours. Filter for station records where freeBikes equals zero or freeBikes equals totalSlots to flag rebalancing bottleneck points.

Deliverable: An aggregated report listing station IDs categorized by the frequency of zero-bike or zero-slot states.

Stop condition: Station records return null or zero for totalSlots across more than 10 percent of the target network.

What breaks, and how do you design around it?

When a target network does not report e-bike data, those specific fields are omitted from the station record entirely. Handle missing e-bike keys in your ingestion pipeline by setting default null or zero values rather than throwing parsing errors. If you reach your dataset limit on broad country runs, narrow your search by querying specific networkId targets across individual scheduled runs.

When should you not use CityBikes Scraper?

Do not use this Actor if you require long-distance ground transportation schedules or long-term intercity travel options. For regional bus routes and cross-country transit options, use FlixBus Scraper or Amtrak Scraper instead. Skip this Actor if your project requires user transaction histories, pricing tiers, or historical trip logs, as the CityBikes API provides only real-time snapshot data.

What should you check before trusting the output?

• Verify freeBikes and emptySlots sum to totalSlots on all station records.
• Check that scrapedAt contains a valid ISO timestamp and is not empty.
• Flag any station records missing latitude or longitude coordinate values.
• Halt execution if a byNetwork run returns zero station records for a known active network ID.
• Alert when consecutive runs return identical lastUpdated values for an active station.

None of this proves a record is correct. It gives a scheduled CityBikes Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does running CityBikes Scraper cost on the free plan?

Results cost $0.005 per record, which equals $5.00 per 1,000 results on the free plan. Apify's free plan includes $5.00 of monthly prepaid usage, covering up to 1,000 results each month before platform compute charges are added.

How do I find a specific networkId for my city?

Run the Actor in listNetworks mode. This outputs network records containing company names, cities, country codes, and unique networkId strings such as santander-cycles or citi-bike-nyc.

Does this scraper collect historical station data?

No. The scraper fetches live state data directly from the CityBikes API, which reflects real-time station conditions updated every 60 to 120 seconds. To build historical datasets, run the Actor on a recurring schedule.

Why are e-bike counts missing from some station records?

E-bike metrics are only included when the underlying bike-share operator exports them through their feed. If an operator does not track or expose e-bike counts, those fields are omitted from the record.

Can I fetch only network summaries without full station lists?

Yes. Set includeStations to false in your input configuration. The Actor will then emit only network-level records containing network names, locations, and company info without pulling individual station data.

Where to go next

When you are ready to run it, open CityBikes Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• PlugShare EV Charging Station Scraper: Scrape PlugShare's crowd-sourced EV charging station map - user check-ins, reviews, ratings, live outlet-availability status, PlugScore, and user photos, alongside station address, connectors, network, and pricing.
• FlixBus Scraper: Scrape FlixBus - Europe and North America's largest intercity bus network.
• Amtrak Scraper: Scrape Amtrak - America's intercity passenger rail network.
• TickPick Scraper: Scrape TickPick.com - the no-fee ticket resale marketplace.
• Banggood Product & Price Scraper: Scrape Banggood.com - search by keyword, browse by category, or fetch full product detail by URL.
• Centris Real Estate Scraper: Scrape Centris.ca - Quebec's official real estate listing network.
• VietnamWorks Jobs Scraper: Scrape live job listings from VietnamWorks.com, Vietnam's largest job board.
• TikTok LIVE Event Stream Scraper: Capture real-time events from TikTok LIVE streams including chat messages, gifts, likes, joins, shares, and viewer stats.

Related guides:

• PlugShare EV Charging Station Scraper: $5.00 per 1,000 Results (2026)
• TickPick Scraper: Up to 1,000 Free Results a Month (2026)
• TikTok LIVE Event Stream Scraper: 3 Operational Playbooks
• Banggood Product & Price Scraper: 28 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-03.

• Actor last updated by its maintainers on 2026-06-11.

• Run outcome figures cover the 30 day public window ending 2026-10-03.

• CityBikes Scraper on Apify