What is OpenTimes?

In this case, a travel time is just how long it takes to get from location A to location B when following a road or path network. Think the Google Maps or your favorite smartphone mapping service. OpenTimes provides billions of these times, all pre-calculated from public data. It also provides the distance traveled for each time, though unlike a smartphone map, it does not provide the route itself.

Times are between the population-weighted centroids of United States Census geographies. See Data for a full list of 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 include transit once Valhalla (the routing engine OpenTimes uses) incorporates multi-modal costing into their matrix API.

Kind of. They’re accurate relative to the other times in this database (i.e. the 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 more a more in-depth technical overview of the project, visit the OpenTimes GitHub page.

OpenTimes currently uses three major data inputs:

1. OpenStreetMap data. Specifically, the yearly North America extracts from Geofabrik.
2. Elevation data. Automatically downloaded by Valhalla. Uses the public Amazon Terrain Tiles.
3. Origin and destination points. Derived from the centroids of U.S. Census TIGER/Line data.

Input and intermediate data are built and cached by DVC. The total size of all input and intermediate data is around 750 GB. In the future, OpenTimes will also use GTFS data for public transit routing.

All travel time calculations require some sort of routing engine to determine the optimal path between two locations. OpenTimes uses Valhalla because it’s fast, has decent Python bindings, can switch settings on the fly, and has a low memory/resource footprint.

U.S. states are used as the unit of work. For each state, I load all the input data (road network, elevation, etc.) for the state plus a 300km buffer around it. I then use the Valhalla Matrix 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 very large network. However, they’re also fairly easy to parallelize since each origin can be its own job, independent from the other origins.

I use a combination of GitHub Actions and a beefy home server to calculate the times for OpenTimes. On GitHub Actions, I use a workflow-per-state model, where each state runs in a parameterized workflow that splits the work into many smaller jobs that run in parallel. This works surprisingly well and lets me calculate tract-level times for the entire U.S. in about a day.

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 provided R or Python wrapper packages.

To learn more about how to access the data, see the dedicated Data section.

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 DuckDB compiled to WebAssembly. It then updates the map fill using the returned destination IDs and times.

The Parquet files that it queries are supposed to be cached by Cloudflare’s CDN. However, Cloudflare really doesn’t seem to like very large files sitting in its caches, so they’re constantly evicting them.

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. Also, each state has its own file, so if you’re switching between states you’re more likely to encounter a cold cache.

I pay out of pocket for the (currently) small hosting costs. I’m not currently seeking funding or sponsors, though I may in the future in order to buy things like traffic data.

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 GitHub project 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 Valhalla.