Trip World is a publicly redistributable, METRO-level cross-city travel benchmark. It pairs a large corpus of out-of-town travel sequences with rich Foursquare and Google Maps point-of-interest (POI) metadata and an unified Google reviews corpus. The dataset is designed to support:

Trajectory recommendation — recommend a sequence of POIs in an unfamiliar city, given the traveller's home-city behaviour and a desired start / end / length.
Cross-city POI ranking and next-POI prediction — score POIs in a destination region by likelihood for an out-of-town visitor.
Place modelling — text/category/sentiment work driven by 186 M Google reviews and structured FSQ + Google attributes for 687 K POIs.
Tourism and mobility analytics — aggregate analyses of travel flows between 1,173 cities in 90+ countries.

The release is built on top of the STD-2018 check-in stream, with metro- consolidation, hometown discovery, traveller filtering, and POI enrichment applied; see Provenance below for the exact pipeline.

Headline statistics

Quantity	Value
Travel-behavior records (τ)	518,567
Distinct travellers	148,402
Hometown regions / destination regions	723 / 1,165
Distinct (hometown → destination) pairs	6,246
Qualifying check-ins	7,416,219
Distinct trails (sessions)	2,723,551
Distinct POIs	687,173
POIs with Google metadata	309,941 (45%)
POIs with ≥ 1 review	285,693 (42%)
Total reviews	186,760,186
POIs with extra place attributes (desc / hours / price)	28,776
Distinct cities (Wikidata QIDs)	1,173
Time span	2017-10-03 — 2018-10-20

Geographic coverage is strongest in East Asia and the Mediterranean (Japan, Turkey, Malaysia, USA, Brazil, Thailand, Mexico, Philippines …). See the figures bundled with the source repository for breakdowns.

Definitions

A travel-behavior record captures one traveller's activity around one out-of-town destination. Following the dataset's formal definition, each τ record is a five-tuple

τ = (u, c_h, c_o, r_h, r_o)

with the following components:

Symbol	Meaning
`u`	the traveller (anonymous integer ID, 1..148,402)
`r_h`	their identified hometown region (Wikidata city QID)
`r_o`	the out-of-town destination region (Wikidata city QID)
`c_h`	the traveller's check-in stream at home around this trip
`c_o`	the traveller's check-in stream at the destination

c_h and c_o are sequences of (trail_id, venue_id, venue_category, venue_schema, ts) records. Each trail_id identifies a single contiguous session of check-ins (one "trajectory" in the trajectory- recommendation sense); a single τ record may contain several distinct trails on each side because the same traveller can have multiple home sessions and multiple visits to the same destination.

A POI is identified by a Foursquare place ID (foursquare:<24-hex>). Each POI is annotated with a Wikidata-QID locality (the city it belongs to), a Foursquare venue category, a schema.org venue type, and (for ~45 % of POIs) the corresponding Google Maps CID and rich Google metadata.

Layout

trip_world/
├── README.md                          (this file)
├── MANIFEST.json                      — file list with sizes, sha256, and row counts
├── metro_mapping_clean.json           — metro consolidation map (municipality QID → parent metro QID)
├── travel_behaviors.parquet           — 518,567 τ records
├── pois.parquet                       — 687,173 POI summaries (per-POI usage stats + flat google_*)
├── region_labels.parquet              — 1,173 (region_id → city name + country)
├── metadata/
│   ├── metadata_all.parquet           — 687,173 rows; full Foursquare + Google metadata per POI
│   └── place_attributes.parquet       — 28,776 rows; description / hours / price for the most enriched POIs
├── reviews/
│   └── reviews_all.parquet            — 186,760,186 unified Google reviews
└── _scripts/                          — full build-pipeline source code (reproduces the dataset)

Schema (column reference)

`travel_behaviors.parquet` (518,567 rows)

Column	Type	Notes
`user_id`	int64	1..148,402, fresh public IDs (see Privacy)
`r_h`	string	hometown region — Wikidata QID, e.g. `Q35178`
`r_o`	string	destination region — Wikidata QID
`n_home_ci`	int64	total home-side check-ins in `c_h`
`n_travel_ci`	int64	total destination-side check-ins in `c_o`
`c_h`	list	home check-ins (see element schema below)
`c_o`	list	destination check-ins (same element schema)

Each element of c_h / c_o is:

Field	Type	Notes
`trail_id`	int64	1..2,723,551 (fresh public IDs) — same trail can re-appear across τ records
`venue_id`	string	`foursquare:<24-hex>` POI key
`venue_category`	string	Foursquare category UUID (4-byte hex, optional)
`venue_schema`	string	schema.org venue type, e.g. `schema:CafeOrCoffeeShop`
`ts`	timestamp[us, UTC]	observation time

`pois.parquet` (687,173 rows)

POI-level summary, optimised for the 99 % of analyses that only need the flat columns. Every POI in the benchmark appears exactly once.

Column	Type	Notes
`fsq_place_id`	string	primary key
`locality`	string	Wikidata QID of the city
`venue_category`	string	Foursquare category UUID
`venue_schema`	string	schema.org type
`n_checkins`	int64	total check-ins for this POI in the dataset
`n_users_visited`	int64	distinct travellers who visited
`google_cid`	string \| null	Google Maps customer ID (= `place_id` in some APIs)
`google_name`	string \| null	Google business name
`google_full_address`	string \| null	Google formatted address
`google_address`	string \| null	Google street address
`google_website`	string \| null	Google business website
`google_rating`	double \| null	average Google star rating
`google_num_reviews`	int64 \| null	Google review count
`google_categories`	list \| null	Google category labels
`google_place_id`	string \| null	Google Places API ID (when known)
`google_gmaps_url`	string \| null	canonical maps.google.com URL
`google_meta_source`	string	one of `v1_search`, `gcp_search`, `inline`, …
`has_google_metadata`	bool	convenience flag
`n_reviews`	int64	reviews available for this POI
`n_reviews_with_text`	int64	reviews with non-empty text
`review_source`	string	provenance tag
`has_reviews`	bool	convenience flag

`metadata/metadata_all.parquet` (687,173 rows)

Per-POI Foursquare + Google metadata. Same fsq_place_id primary key as pois.parquet; richer FSQ fields (name, lat/lon, address, country, website, …). Personal-leaning Foursquare contact fields (fsq_email, fsq_tel, fsq_facebook_id, fsq_instagram, fsq_twitter) are intentionally not present.

Notable columns: fsq_name, fsq_latitude, fsq_longitude, fsq_address, fsq_locality, fsq_region, fsq_country, fsq_postcode, fsq_formatted_address, fsq_category_ids, fsq_category_labels, fsq_website, fsq_date_created, fsq_date_refreshed, fsq_date_closed.

The google_* columns mirror those in pois.parquet.

`metadata/place_attributes.parquet` (28,776 rows)

Rich place-level attributes for the most enriched POIs (descriptions, opening hours, price tier, free-form attributes).

Column	Type	Notes
`fsq_place_id`	string	join key
`google_cid`	string	the Google CID this enrichment came from
`search_query`	string	query used to recover the place
`match_dist_m`	double	metres between FSQ point and Google point
`match_name_sim`	double	normalized name-similarity score
`description_short`	string	one-line description
`description_long`	string	longer description
`hours_today`	string	today's opening hours, free-text
`hours_week`	string	weekly hours, free-text
`price_token`	string	Google price symbol (`$`, `$$`, …)
`price_min`	string	min price (when known)
`price_max`	string	max price (when known)
`attributes`	string	JSON-encoded attribute bag
`n_inline_reviews`	int64	count of reviews scraped at enrichment time
`fetched_at`	string	timestamp of enrichment fetch

`region_labels.parquet` (1,173 rows)

Column	Type	Example
`region_id`	string	`Q100`
`city_name`	string	`Boston`
`country_qid`	string	`wd:Q30`
`country_name`	string	`United States`

`reviews/reviews_all.parquet` (186,760,186 rows)

Unified Google reviews corpus, one row per review.

Column	Type	Notes
`fsq_place_id`	string	links to `pois.parquet`
`google_cid`	string	links to `metadata_all.parquet`
`review_id`	string	Google's review ID
`rating`	int64	1..5
`text`	string	original review text (may be empty)
`text_translated`	string \| null	Google's machine translation, if any
`lang`	string \| null	BCP-47 language tag
`relative_time`	string \| null	Google's "3 weeks ago" string
`timestamp_us`	int64	absolute review time, microseconds since epoch
`review_time`	timestamp[us, UTC]	same value, parsed
`owner_reply`	string \| null	business-owner reply text, if any
`source`	string	provenance tag (`v1_refetch`, `listugcposts_resume`, `inline`, …)
`author_pid`	string	salted blake2b 16-hex pseudonym (see Privacy)

The display name and Google profile ID of each reviewer are removed from the public release; the author_pid column lets you link multiple reviews from the same author within the dataset without exposing real identities.

`metro_mapping_clean.json`

A JSON dictionary mapping individual municipality QIDs to the parent metro QID used as region_id everywhere else. Useful if you want to recover the original sub-municipal granularity, or extend the mapping.

Quick start

The release uses Apache Parquet throughout; any tool that reads parquet will work. Below are minimal examples in three common stacks.

Python — pandas / pyarrow

import pandas as pd, pyarrow.parquet as pq
ROOT = "/path/to/trip_world"

travel  = pq.read_table(f"{ROOT}/travel_behaviors.parquet").to_pandas()
pois    = pq.read_table(f"{ROOT}/pois.parquet").to_pandas()
regions = pq.read_table(f"{ROOT}/region_labels.parquet").to_pandas()

# How many trips originate from each city?
top_origins = (travel.merge(regions, left_on="r_h", right_on="region_id")
                     .groupby("city_name").size()
                     .sort_values(ascending=False).head(10))
print(top_origins)

Python — DuckDB (recommended for the 22 GB review file)

DuckDB streams parquet without loading everything into RAM and supports the full SQL surface, including joins across files.

import duckdb
con = duckdb.connect()

con.execute(f"""
  CREATE VIEW travel  AS SELECT * FROM '{ROOT}/travel_behaviors.parquet';
  CREATE VIEW pois    AS SELECT * FROM '{ROOT}/pois.parquet';
  CREATE VIEW regions AS SELECT * FROM '{ROOT}/region_labels.parquet';
  CREATE VIEW reviews AS SELECT * FROM '{ROOT}/reviews/reviews_all.parquet';
""")

# Top destinations for travellers from Boston (Q100):
con.sql("""
  SELECT regions.city_name, COUNT(*) AS trips
  FROM travel JOIN regions ON travel.r_o = regions.region_id
  WHERE travel.r_h = 'Q100'
  GROUP BY regions.city_name
  ORDER BY trips DESC
  LIMIT 10
""").show()

# Average review rating per category in Tokyo:
con.sql("""
  SELECT pois.venue_schema,
         AVG(reviews.rating)        AS avg_rating,
         COUNT(*)                   AS n
  FROM reviews
  JOIN pois ON reviews.fsq_place_id = pois.fsq_place_id
  WHERE pois.locality = 'Q1490'   -- Tokyo
  GROUP BY pois.venue_schema
  HAVING COUNT(*) > 100
  ORDER BY avg_rating DESC
""").show()

Iterating over the trajectories of one traveller

import pyarrow.parquet as pq, pandas as pd
tb = pq.read_table(f"{ROOT}/travel_behaviors.parquet").to_pandas()

row = tb.iloc[0]
print(f"User {row['user_id']} travelled from {row['r_h']} to {row['r_o']}")
print(f"  {row['n_home_ci']} home check-ins, {row['n_travel_ci']} destination check-ins")

# Group destination check-ins by trail (= individual trajectory):
import collections
trails = collections.defaultdict(list)
for ck in row["c_o"]:
    trails[ck["trail_id"]].append(ck)

for trail_id, points in trails.items():
    points.sort(key=lambda p: p["ts"])
    venues = " → ".join(p["venue_schema"] for p in points)
    print(f"  trail {trail_id}: {venues}")

Counting reviews per place without loading all 22 GB

con.sql("""
  SELECT fsq_place_id, COUNT(*) AS n_reviews
  FROM '{ROOT}/reviews/reviews_all.parquet'
  GROUP BY fsq_place_id
  ORDER BY n_reviews DESC
  LIMIT 20
""".format(ROOT=ROOT)).show()

Common join patterns

To go from …	… to …	Join key
τ record	hometown / destination name	`travel.r_h = regions.region_id` (and `r_o`)
τ record	per-POI usage / Google meta	element `venue_id = pois.fsq_place_id`
τ record	full FSQ + Google metadata	element `venue_id = metadata_all.fsq_place_id`
POI summary	rich place attributes	`pois.fsq_place_id = place_attributes.fsq_place_id`
POI summary	reviews	`pois.fsq_place_id = reviews.fsq_place_id`
Reviews	place-level Google ratings	`reviews.google_cid = pois.google_cid`
Reviews	author identity (within set)	`reviews.author_pid` (no external linking)
Region	municipalities folded into it	`metro_mapping_clean.json[municipality_qid] == region_id`

Privacy and redaction

The following transforms have been applied relative to the build-time working set so the release can be redistributed without exposing individual identities:

User IDs. user_id in travel_behaviors.parquet is remapped to a fresh consecutive 1..148,402 sequence; original STD-2018-derived IDs are not present.
Trail IDs. trail_id inside each c_h / c_o element is likewise remapped to a fresh consecutive 1..2,723,551 sequence.
Reviewer identity. Reviewer display names (author) are removed entirely. The original numeric Google author_id is replaced with a salted blake2b pseudonym author_pid (16 hex characters per author). The salt is generated at release time and kept private; cross-review author linking remains possible inside the dataset but cannot be inverted to a real Google profile.
Foursquare contact fields. The columns fsq_email, fsq_tel, fsq_facebook_id, fsq_instagram, fsq_twitter are dropped from metadata_all.parquet.
Review text. Review bodies are kept verbatim (they are the dataset's primary signal). Users of this release should be aware that user-generated text may incidentally contain personal references and should treat downstream analyses accordingly.

If you discover residual identifying information that we missed, please contact the maintainers so it can be redacted in the next release.

Reproducibility

The build-pipeline source is shipped under _scripts/ for documentation and audit purposes. Re-running it end-to-end requires several external data sources that are not part of this release — see the table below. The released parquet files are the canonical artefacts; the scripts let you verify how they were produced and re-derive subsets you may need.

What the scripts can re-derive

Stage(s)	Output	External data needed
0–6	metro map, τ records, POIs, region labels	STD-2018 raw check-in CSV
7	per-POI Foursquare metadata	Foursquare Open Source Places parquet dump
10	extra FSQ enrichment for new POIs	Foursquare Open Source Places parquet dump
11	FSQ-API rescue of unresolved POIs	Foursquare Places API key
12–13	UCSD-bridge Google metadata for new POIs	UCSD all20 + benchmark POI corpus
14–16	merged Google reviews + place attributes	raw GCP scrape shards (not redistributable; the scrape code is not included)

In other words, the structural side of Trip World (τ records, POIs, region labels, FSQ metadata) can be reproduced if you supply STD-2018 and an FSQ-OS dump. The Google reviews corpus cannot be re-derived from this release alone — it is provided as a static parquet because the scrape that produced it is not redistributable.

Configuring paths

All scripts read their filesystem locations from environment variables so the source tree contains no personal paths. Defaults assume the script is launched from inside the release's _scripts/ subfolder.

export TRIP_WORLD_ROOT=/path/to/trip_world           # default: ../ relative to the script
export STD_2018_PATH=/path/to/std_2018.csv           # raw STD-2018 stream
export FSQ_OS_PARQUET_GLOB="/path/to/fsq_os/places/parquet/*.parquet"
export CROSS_CITY_V1_ROOT=/path/to/cross_city_v1     # optional, only for stages 5,7,8,9,16
export GMAPS_FULL_ROOT=/path/to/gmaps_full_dataset   # optional, only for stage 12
export METRO_V2_JSON=/path/to/metro_mapping_v2.json  # optional, only for stage 0
export DUCKDB_TMP_DIR=/tmp/duckdb_trip_world          # any large local scratch directory
export FSQ_API_KEY=fsq3...                            # only if running stage 11

Stage-by-stage map

_scripts/00_build_metro_map.py            — metro consolidation map (Wikidata SPARQL)
_scripts/01_consolidate_filter.py         — apply consolidation, filter to MIN_PAIR
_scripts/02_hometown_discovery.py         — temporal-decay hometown identification
_scripts/03_build_travelers.py            — split travellers / non-travellers
_scripts/04_build_travel_behaviors.py     — emit τ records
_scripts/05_build_pois.py                 — per-POI usage stats
_scripts/06_build_region_labels.py        — Wikidata-derived city names
_scripts/07_subset_metadata.py            — slice FSQ-OS metadata
_scripts/08_subset_reviews.py             — slice reviews
_scripts/09_validate_and_readme.py        — invariants + descriptive stats
_scripts/10_enrich_new_pois.py            — local-dump enrichment for new POIs
_scripts/11_fsq_api_recover.py            — live FSQ Places API recovery
_scripts/12_ucsd_bridge.py                — UCSD all20+bench match
_scripts/13_merge_ucsd_into_metadata.py   — merge UCSD matches into metadata
_scripts/14_merge_gcp_search_results.py   — merge Stage-1 GCP scrape shards (shards not shipped)
_scripts/15_merge_stage2_reviews.py       — merge Stage-2 listugcposts shards (shards not shipped)
_scripts/16_unify_v1_and_new_reviews.py   — final review unification
_scripts/lib_wikidata.py                  — small Wikidata helper
_scripts/viz_clean_raw.py                 — descriptive figures
_scripts/viz_traj_length.py               — trajectory-length figure

No API keys are embedded in any released script; stages that hit external services (Wikidata SPARQL, FSQ Places API) read credentials from environment variables or CLI flags exclusively.

Citation

If you use Trip World in academic work, please cite the accompanying paper (BibTeX entry to be released alongside the official publication).

License

The Trip World release is distributed for non-commercial research use only. Redistributions must preserve this README and the provenance scripts in _scripts/. Use of the dataset implies acceptance of the upstream Foursquare Open Source Places licence and the Google Maps Platform Terms of Service for any further analysis that re-fetches data from those services.

Released on 2026-05-05.

Downloads last month: 209

Total file size:

23.7 GB

Trip World