What is OpenTimes?

In this case, a travel time is just how long it takes to get from location A to location B while following a road or path network. Think Google Maps or your favorite smartphone mapping service. OpenTimes provides billions of these times, all pre-calculated from public data. However, unlike a smartphone, OpenTimes does not provide the route itself, only the time between the two points.

Times are between the population-weighted centroids of United States Census geographies. Centroids are weighted because sometimes Census geographies are huge and their unweighted centroid is in the middle of a desert or mountain range. However, most people don’t want to go to the desert, they want to go to where other people are. Weighting the centroids moves them closer to where people actually want to go (i.e. towns and cities).

Currently, driving, walking, and biking are included. I plan to add transit once Valhalla (an alternative to the main OSRM routing engine OpenTimes uses) adds multi-modal costing to their Matrix API.

Kind of. They’re accurate relative to the other times in this database (i.e. they are internally consistent), but may not align perfectly with real-world travel times. Driving times tend to be especially optimistic (faster than the real world). My hope is to continually improve the accuracy of the times through successive versions.

Currently, driving times do not include traffic. This has a large effect in cities, where traffic greatly influences driving times. Times there tend to be at least 10-15 minutes too fast. It has a much smaller effect on highways and in more rural areas. Traffic data isn’t included because it’s pretty expensive and adding it might limit the open-source nature of the project.

Please file a GitHub issue. However, understand that given the scale of the project (billions of times), the priority will always be on fixing systemic issues in the data rather than fixing individual times.

For a more in-depth technical overview of the project, visit the OpenTimes GitHub page.

OpenTimes currently uses two major data inputs:

1. OpenStreetMap data. Specifically, the yearly North America extracts from Geofabrik.
2. Census data. Specifically, U.S. Census TIGER/Line shapefiles, which are used to construct origin and destination points.

Input and intermediate data are built and cached by DVC. The total size of all input and intermediate data is around 300 GB.

All travel time calculations require some sort of routing software to determine the optimal path between two locations. OpenTimes uses Open Source Routing Machine (OSRM) because it’s the only routing engine that can generate continent-scale distance matrices at a reasonable speed (Valhalla and R5 are too slow).

U.S. states are used as the unit of work. For each state, I load all the input data (road network, points, etc.) for the state plus a 300km buffer around it. I then use the OSRM Table API to route from each origin in the state to all destinations in the state plus the buffer area.

Travel times are notoriously compute-intensive to calculate at scale, since they basically require running a shortest path algorithm many times over a huge network. However, travel time calculations are also fairly easy to parallelize, since each origin can be its own discrete job.

I use GitHub Actions to parallelize the calculations by creating a job for each state and year. This works surprisingly well and lets me calculate tract-level times for the entire U.S. in about 12 hours.

Data is served via Parquet files sitting in a public Cloudflare R2 bucket. You can access a list of all the files here. Files can be downloaded directly, queried with DuckDB or Arrow, or accessed via the (forthcoming) R or Python wrapper packages.

To learn more about how to access the data, see the GitHub README.

It’s surprisingly cheap. Basically the only cost is R2 storage from Cloudflare. Right now, total costs are under $15 per month.

The homepage uses Maplibre GL JS to show maps. The basemap is OpenFreeMap’s Positron. The tract-level boundaries are TIGER/Line cartographic boundaries converted to PMTiles using Tippecanoe and hosted on R2.

When you click the map, your browser queries the Parquet files on the public bucket using hyparquet. It then updates the map fill using the returned destination IDs and times.

The big Parquet files that it queries are supposed to be cached by Cloudflare’s CDN. However, Cloudflare doesn’t like large files sitting in its caches, so the files are constantly getting evicted.

If you click the map and it’s slow, it’s likely that you’re hitting a cold cache. Click again and it should be much faster. Each state has its own file, so if you’re switching between states you’re more likely to encounter a cold cache.

It’s not. I pay out of pocket for the (small) hosting costs.

Yes, go for it.

No. However, note that the data is hosted by Cloudflare, which may impose its own limits if it determines you’re acting maliciously.

Attribution is required when using OpenTimes data.

Please see the CITATION file on GitHub. You can also generate APA and BibTeX citations directly from the project’s GitHub page.

OpenTimes uses the MIT license. Input data is from OpenStreetMap and the U.S. Census. The basemap on the homepage is from OpenFreeMap. Times are calculated using OSRM.