Busbud Bus & Train Fare Scraper: 26 Data Fields per Record (2026)

Each output record carries 26 fields, including deep booking links, operator names, departure and arrival times, and route-level price context across more than 500 transit operators worldwide. This data collector runs entirely via HTTP and bypasses heavy browser automation, providing a lightweight way to extract schedule listings for transit corridors. It is ideal for developers building routing directories, price trackers, and local search portals, but it is not suitable for users who need ticket inventories further than eight days in advance, as the source only publishes a rolling schedule window.

Try it: open Busbud Bus & Train Fare Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Busbud Bus & Train Fare 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 Busbud Bus & Train Fare Scraper a month, before run-start charges and platform usage.

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

Busbud Bus & Train Fare Scraper was last updated on 2026-07-04. It is one of 1,729 Actors CrawlerBros publishes on Apify, which together have 746,619 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Busbud Bus & Train Fare 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.

The result charge depends entirely on how many departure items are written to your dataset. To control costs, use the maxItems setting to cap the total results emitted per run. The cheapest way to test your setup is to run a single route with maxItems set to 50, which caps your result charges at $0.25 on the free plan.

How do you run Busbud Bus & Train Fare Scraper from the API?

The schema marks 2 of its 12 controls as required: origin, destination. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

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~busbud-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"origin":"Boston","destination":"New York City","routePairs":[],"vehicleType":"any","currency":"USD","sortBy":"recommended","maxItems":50,"proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "origin": "Boston",
  "destination": "New York City",
  "routePairs": [],
  "vehicleType": "any",
  "currency": "USD",
  "sortBy": "recommended",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~busbud-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 = {
  "origin": "Boston",
  "destination": "New York City",
  "routePairs": [],
  "vehicleType": "any",
  "currency": "USD",
  "sortBy": "recommended",
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

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

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Busbud Bus & Train Fare Scraper inputs matter, and which can you skip?

The origin and destination fields are the only two required controls and must contain city names. For multi-route processing, populate the routePairs array with JSON objects to run a batch scrape, which completely overrides the single origin and destination inputs.

• origin (string): Starting city name. Ignored if routePairs is provided. Default: "Boston".
• destination (string): Ending city name. Ignored if routePairs is provided. Default: "New York City".
• routePairs (array): Provide multiple {"origin": "...", "destination": "..."} pairs to scrape several routes in one run. When non-empty, this overrides the single origin/destination fields above. Default: [].
• date (string): Only keep departures on this date. Busbud publishes a rolling ~8-day schedule window starting today; dates outside that window return 0 results. Leave blank to keep every date in the published window.
• vehicleType (string): Only keep departures using this vehicle type. Default: "any".
• operatorName (string): Only keep departures whose operator name contains this text (case-insensitive). Examples: Flixbus, Greyhound, Peter Pan, OurBus, Alsa, National Express. Leave blank to keep every operator.
• maxDurationMinutes (integer): Drop departures whose total travel time exceeds this many minutes.
• maxPrice (number): Drop departures whose price exceeds this amount (in the selected currency).
• currency (string): Re-price every departure in this currency (Busbud's own currency switcher, applied server-side). Default: "USD".
• sortBy (string): How to order the emitted departures. Default: "recommended".
• maxItems (integer): Hard cap on total departures emitted across all requested routes. Default: 50.
• proxyConfiguration (object): Uses Apify's free AUTO proxy group to reduce the chance of rate-limiting. Not strictly required. Default: {"useApifyProxy":true}.

Fixed-choice controls: vehicleType accepts any (Any vehicle type), bus, train, shuttle, minibus, ferry; currency accepts 30 values (default USD), including USD (US Dollar), CAD (Canadian Dollar), EUR (Euro), GBP (British Pound); sortBy accepts recommended (Busbud's default order), cheapest (Cheapest first), fastest (Fastest first), departureTime (Earliest departure first).

What does Busbud Bus & Train Fare Scraper return?

The returned records contain rich transit listings with operator names, equipment types, amenities, and localized prices. They do not contain backend seats-remaining counts or historical ticket pricing databases.

• origin, destination - canonical city names for the route
• date - the calendar date (YYYY-MM-DD) this departure runs
• operator - carrier name (e.g. FlixBus, Greyhound Lines, Inc., OurBus)
• vehicleType - e.g. bus, train
• amenities[] - on-board amenities shown for this departure (e.g. Wifi, Toilet, Power outlets)
• tags[] - Busbud's own badges for this departure, e.g. Cheapest, Fastest
• departureTime, departureDateTime, departureLocation
• arrivalTime, arrivalDateTime, arrivalLocation
• durationMinutes, durationText
• price, currency
• bookingLink - deep link to book this specific departure on Busbud
• routeLowPrice, routeHighPrice, routeDailyOfferCount - route-level fare context
• routeDistanceMiles, routeDistanceKm - route-level distance
• sourceUrl - the Busbud route page this was scraped from
• recordType: "departure", scrapedAt

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 Busbud Bus & Train Fare 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 a quick smoke test by setting origin to Boston and destination to New York City with maxItems limited to 5.
2. Verify the output dataset contains valid records and check that the origin and destination fields reflect the canonical city names resolved by the platform.
3. Inspect the departureTime and departureDateTime fields to confirm they match your timezone assumptions.
4. Switch to batch mode by passing multiple route configurations into the routePairs array while leaving the top-level origin and destination fields empty.
5. Specify a valid YYYY-MM-DD format in the date field, keeping in mind that dates must fall within the rolling schedule window of roughly eight days.
6. Configure your target currency using the three-letter ISO code to let the server handle price conversion.
7. Implement an automatic filter downstream to exclude any record where the price field is missing or the operator is not on your allowed whitelist.
8. Verify the output format and ensure the bookingLink field is present for deep linking directly to the booking portal.

How do you apply it? Three worked playbooks

These are Busbud Bus & Train Fare Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Travel booking comparison tools

Outcome: Pull live bus/train fares into a fare-comparison UI

Configure: Set origin to "Paris", destination to "Amsterdam", currency to "EUR", and maxItems to 100.

Working method: Run the Actor for your main city pairs, parse the returned dataset, and map the price, operator, and departureTime fields directly to your front-end fare comparison table.

Deliverable: A structured JSON feed of active departure listings containing prices, times, operator details, and booking links.

Stop condition: The returned dataset is empty or prices default to USD instead of EUR.

Use case 2: Price tracking

Outcome: Snapshot fares for a route over time to spot trends

Configure: Set origin to "Toronto", destination to "Montreal", sortBy to "cheapest", and run daily without a specific date to capture the full rolling window.

Working method: Schedule the Actor to run every 24 hours, dump the resulting datasets into a relational database, and compare the routeLowPrice and routeHighPrice fields across runs to build historical trend lines.

Deliverable: A time-series database table tracking the daily minimum, maximum, and average fares for the specified corridor.

Stop condition: The routeDailyOfferCount drops to zero across multiple scheduled runs.

Use case 3: Travel content/SEO

Outcome: Power "how to get from X to Y by bus" articles with real schedules

Configure: Set routePairs to [{"origin": "Calgary", "destination": "Banff"}, {"origin": "Montreal", "destination": "Quebec City"}] and maxItems to 50.

Working method: Execute the batch scrape weekly, extract the unique list of operator names, average durationMinutes, and the typical daily departure count, then template those values directly into your static site generator.

Deliverable: Updated travel route directories displaying active transit operator names, average travel durations, and direct ticket booking links.

Stop condition: The resolved origin or destination fields mismatch the requested batch city pairs.

What breaks, and how do you design around it?

If you query dates further than roughly eight days out, the platform returns zero records. To work around this limitation, you must schedule your runs to track the rolling schedule window incrementally as the dates open up.

When should you not use Busbud Bus & Train Fare Scraper?

Do not use this Actor if you need to plan routes or query schedules that span multiple connection points or require airline flights, as it is limited strictly to direct ground transportation available on Busbud. For comprehensive multi-modal planning that includes flights, rideshares, and driving directions, use the Rome2Rio Multi-Modal Route Scraper instead. Additionally, if you only require train-specific schedules across the UK and Europe with deep railcard discount options, the Trainline Scraper is a more specialized alternative.

What should you check before trusting the output?

• Check if the price field is present on every departure record, as missing fares indicate the route is sold out or unavailable.
• Validate that departureDateTime is a valid ISO timestamp and chronological to the scrapedAt timestamp.
• Confirm that the currency field matches the requested ISO code instead of defaulting to USD.
• Monitor the total count of returned records; if a route consistently returns zero items, verify that the travel date is within the rolling eight-day window.
• Ensure that bookingLink contains a fully qualified URL starting with the correct platform domain.

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

Frequently asked questions

How much does it cost to run this Actor?

It costs $0.005 per result on the free tier, which amounts to $5.00 per 1,000 results. Apify also bills for the platform CPU and memory usage your run consumes on top of these result-based charges.

Can I search for dates far in the future?

No. The source platform only publishes a rolling schedule window of about eight days. If you provide a travel date outside this window, the Actor will return zero results instead of failing.

How do I scrape multiple routes at once?

You can use the routePairs batch input. Provide an array of origin and destination city pairs in JSON format, which will automatically override the single-city input fields.

What currencies does the pricing output support?

It supports 30 currencies, including USD, EUR, CAD, and GBP. The pricing conversion is handled server-side directly by the source platform based on your input currency selection.

Why do some records lack amenity or tag details?

Empty fields are omitted automatically. If an operator does not publish amenities like WiFi or power outlets, or if the departure has no promotional tag, those specific fields are excluded from the output.

Where to go next

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

Start with the Busbud Bus & Train Fare Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Virail Train & Bus Trip Scraper: Scrape Virail - a free multi-modal travel search comparison site.
• Rome2Rio Multi-Modal Route Scraper: Scrape Rome2Rio trip-planning results - compare flight, train, bus, car, ferry, and rideshare options between any two cities or airports, with durations, price ranges, and operators.
• FlixBus Scraper: Scrape FlixBus - Europe and North America's largest intercity bus network.
• Trainline Scraper: Scrape Trainline - the UK & Europe rail/bus metasearch.
• Direct Ferries Route & Fare Scraper: Compare ferry routes, crossing durations, indicative fares, and operators across P&O Ferries, DFDS, Irish Ferries, Stena Line, Brittany Ferries and 300+ operators worldwide, scraped from directferries.com.

Related guides:

• Virail Train & Bus Trip Scraper: 14 Data Fields per Record (2026)
• Trainline Scraper: Up to 1,000 Free Results a Month (2026)
• Nestpick Scraper: 3 Practical Use Cases
• Google Maps Directions Scraper: Operational Guide and Use Cases
• Hostelworld Scraper: 17,000+ Properties Covered (2026)
• CruiseMapper Cruises Scraper: 3 Practical Use Cases
• Kiwi.com Scraper: Up to 1,000 Free Results a Month (2026)

Resources

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

• Actor last updated by its maintainers on 2026-07-04.

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

• Busbud Bus & Train Fare Scraper on Apify