taziksh/argo-profiles

Argo float profiles (core T/S/P)

Every core profile from the Argo float array, taken from the Argo Global Data Assembly Centre (GDAC). Each profile is one row. That's 3,429,195 profiles from 20,656 floats, 1997 to today. Each row holds the raw and adjusted pressure, temperature and salinity at every measured level, plus the QC flags and the data mode.

Argo is a global array of ~4,000 autonomous floats. Each float drifts at ~1000 m depth and dives to ~2000 m every ~10 days. It then rises to the surface and measures a vertical profile of pressure, temperature and salinity on the way up. Each dive is one numbered cycle. Argo is the main data source for estimates of upper-ocean heat content and salinity change. The source data is spread over hundreds of thousands of NetCDF files, and values are revised over time. This dataset turns it into one table you can query.

What one row is

One row = one profile: one float (platform_number), one cycle_number and one direction ('A' ascending, the usual case, or 'D' descending). The level data are aligned list columns: for a row, pres[i], temp[i], psal[i] and their flags all describe level i. Levels are in the order the float reported them, usually shallow to deep for ascending profiles. All lists in a row have n_levels elements.

The unique key is (dac, profile_id). profile_id is the GDAC file name without its R/D mode letter, e.g. 6901174_012 or 6901174_012D for a descending profile. dac is needed because WMO float numbers are not globally unique on the GDAC. For example, 1902751 is two different floats, one under aoml/ and one under coriolis/.

Why profiles and not levels: there are ~1.36 billion levels. One row per level would repeat all the metadata on each level and spread every profile over hundreds of rows. A row per profile keeps a whole cast together, which is the unit for ML and for vertical integrals such as heat content. DuckDB/Polars UNNEST/explode turn it into long format in one line (see below).

Columns

column	type	meaning
profile_id	string	<wmo>_<cycle>[D], see above
platform_number	string	WMO float number
cycle_number	int32	dive number (0 = launch/test cycle on some floats)
direction	string	A ascending, D descending
data_mode	string	R real-time, A real-time adjusted, D delayed-mode (expert QC'd)
dac	string	Data Assembly Centre (aoml, coriolis, jma, csiro, bodc, meds, incois, csio, kma, kiost, nmdis)
time	timestamp[ms, UTC]	profile time (JULD)
juld_qc	string	QC flag of time
time_location	timestamp[ms, UTC]	time of the position fix (JULD_LOCATION)
latitude, longitude	float64	degrees north / east
position_qc	string	QC flag of the position (8 = interpolated, e.g. under ice)
positioning_system	string	GPS, ARGOS, IRIDIUM, ...
ocean	string	A Atlantic, I Indian, P Pacific (from the GDAC index)
profile_{pres,temp,psal}_qc	string	profile grade A–F: share of levels with good QC (A = 100 %, F = 0 %)
n_levels	int32	number of levels
pres, temp, psal	list	raw pressure (dbar), in-situ temperature (°C, ITS-90), practical salinity (PSS-78)
*_qc	list	per-level QC flag of the raw value
*_adjusted	list	adjusted value (real-time adjustment or delayed-mode correction)
*_adjusted_qc	list	per-level QC flag of the adjusted value
*_adjusted_error	list	uncertainty estimate of the adjusted value (mainly delayed mode)
vertical_sampling_scheme	string	e.g. Primary sampling: averaged [...]
config_mission_number	int32	float mission configuration id
station_parameters	list	parameters measured in this profile
platform_type, wmo_inst_type, profiler_type, float_serial_no, firmware_version		float hardware
project_name, pi_name, data_centre, dc_reference, data_state_indicator	string	provenance
calibration	list	SCIENTIFIC_CALIB_*: parameter, equation, coefficient, comment, date. Records how adjusted values were derived (e.g. the OWC salinity drift correction)
source_file	string	GDAC per-profile file this row matches, e.g. aoml/1902267/profiles/D1902267_001.nc
source_kind	string	prof (read from the float's _prof.nc) or profile (read from the per-profile file)
index_date_update	timestamp[ms, UTC]	date_update of the profile in the GDAC index when it was ingested

Missing values (NetCDF _FillValue 99999) are null. A blank QC flag (' ', "no value, no QC") is also null. If a float doesn't measure a parameter at all (e.g. early temperature-only floats have no salinity), its whole list is null.

Which values to use

This follows the Argo user manual and the GDAC's own "readme before using the data":

1. data_mode D or A: use the *_adjusted columns. In delayed mode, an expert has checked the data and corrected sensor drift, mainly salinity drift. Raw values are kept for reference only. Account for psal_adjusted_error when using delayed-mode salinity.
2. data_mode R: only the raw columns exist. The adjusted lists are empty (null). Raw values have had only automated real-time QC.
3. Keep levels whose QC flag is 1 (good) or 2 (probably good). QC flags: 0 no QC, 1 good, 2 probably good, 3 probably bad (potentially correctable), 4 bad, 5 value changed, 8 estimated (interpolated), 9 missing.
4. Also require position_qc and juld_qc in ('1', '2') if location or time matter, as they do for nearly everything.
5. For climate-quality work (e.g. heat-content trends), many studies use delayed-mode data only (data_mode = 'D'). Real-time salinity can carry uncorrected drift.

import numpy as np

def best(row, var):  # var in {"pres", "temp", "psal"}
    adj = row["data_mode"] in ("A", "D")
    vals = row[f"{var}_adjusted" if adj else var]
    qc = row[f"{var}_adjusted_qc" if adj else f"{var}_qc"]
    if vals is None:
        return np.array([], dtype=np.float32)
    v = np.array(vals, dtype=np.float32)        # None -> nan
    q = np.array([-1 if x is None else x for x in qc])
    return np.where(np.isin(q, (1, 2)), v, np.nan)

Or in DuckDB, as one row per good level:

SELECT profile_id, time, latitude, longitude, p, t, s
FROM (
  SELECT profile_id, time, latitude, longitude,
         unnest(CASE WHEN data_mode IN ('A','D') THEN pres_adjusted    ELSE pres    END) AS p,
         unnest(CASE WHEN data_mode IN ('A','D') THEN pres_adjusted_qc ELSE pres_qc END) AS pq,
         unnest(CASE WHEN data_mode IN ('A','D') THEN temp_adjusted    ELSE temp    END) AS t,
         unnest(CASE WHEN data_mode IN ('A','D') THEN temp_adjusted_qc ELSE temp_qc END) AS tq,
         unnest(CASE WHEN data_mode IN ('A','D') THEN psal_adjusted    ELSE psal    END) AS s,
         unnest(CASE WHEN data_mode IN ('A','D') THEN psal_adjusted_qc ELSE psal_qc END) AS sq
  FROM 'hf://datasets/taziksh/argo-profiles/data/argo_2024-*.parquet'
  WHERE position_qc IN ('1','2') AND juld_qc IN ('1','2')
)
WHERE pq IN (1,2) AND tq IN (1,2);   -- add "AND sq IN (1,2)" when salinity is needed

Quick start

from datasets import load_dataset
ds = load_dataset("taziksh/argo-profiles", split="train", streaming=True)
print(next(iter(ds))["temp"][:5])

# Only one year, via shard file names
ds = load_dataset("taziksh/argo-profiles", data_files="data/argo_2023-*.parquet", split="train")

-- DuckDB: delayed-mode profile counts per year
SELECT year(time) AS y, count(*) FROM 'hf://datasets/taziksh/argo-profiles/data/*.parquet'
WHERE data_mode = 'D' GROUP BY y ORDER BY y;

Files and sharding

data/argo_<period>.parquet is split by profile time: pre2006, then one shard per year for 2006–2012, then one per half-year (YYYY-H1 = Jan–Jun, YYYY-H2 = Jul–Dec) from 2013 on, when profile density rose about 10x. Profiles with no valid time are in argo_undated.parquet. Shards are 77–556 MB each (undated 2 MB), 13.33 GB in all.

Row order inside a shard (recorded in each file's metadata as argo:order):

• Closed shards (every past half-year and year): sorted by platform_number, dac, cycle_number, direction. A float's profiles are contiguous.
• Open shard(s): the current half-year, plus the previous one for 30 days after it ends. These are kept in arrival order (index_date_update, then dac, profile_id), so new and revised profiles sit at the end. Sort by time if you need chronological order. When a half-year closes, its shard is re-sorted by float once. sync/state.json lists the open shards.

Encoding: zstd level 9, byte-stream-split floats, Parquet content-defined chunking (pages of 128–512 KiB raw), and content-defined row groups of about 5,000 profiles. That is ~37% bigger than plain zstd-18 Parquet (9.76 GB). It is chosen so that updating a shard re-uploads only the pages that changed (see the next section).

Why time and not float: time ranges are the most common filter, and the weekly changes land mostly in the newest shard. New real-time profiles all fall in the current half-year. Delayed-mode revisions touch the half-years a reprocessed float was active in. Sharding by float would make every update rewrite nearly every shard, because ~400 floats report each day.

sync/manifest.parquet maps (dac, profile_id) to shard and index_date_update. It and sync/state.json are used by the updater and are not part of the dataset config.

Source, version, licence and citation

• Source: Argo GDAC at Ifremer, https://data-argo.ifremer.fr (rsync vdmzrs.ifremer.fr::argo). Mirrors: US GODAE, and the AWS bucket s3://argo-gdac-sandbox/pub/ (public, no sign-in needed). Profile index: ar_index_global_prof.txt.gz.

• Snapshot: GDAC index dated 2026-10-29 02:24 UTC, retrieved 2026-10-28/29 (UTC). Full build on 2026-10-28 from the index dated 2026-10-28 18:24 UTC, then brought up to date with one update run (662 profiles refreshed).

• Licence: CC BY 4.0, as stated on the Argo SEANOE DOI landing page. This mirror is under the same licence.

• Required acknowledgement, verbatim from the GDAC readme_before_using_the_data.txt:

  These data were collected and made freely available by the International Argo Program and the national programs that contribute to it (http://www.argo.ucsd.edu, http://argo.jcommops.org). The Argo Program is part of the Global Ocean Observing System.

  followed by an Argo DOI. This dataset tracks the live GDAC rather than a frozen snapshot, so cite the general DOI:

  Argo (2000). Argo float data and metadata from Global Data Assembly Centre (Argo GDAC). SEANOE. https://doi.org/10.17882/42182

  If you need to cite a fixed monthly snapshot, the closest one before this build is the 2026-10-14 snapshot: https://doi.org/10.17882/42182#134998. This mirror is not byte-identical to that snapshot. Snapshot DOIs are listed at https://www.seanoe.org/data/00311/42182/ and on the ADMT DOI page.

Known quirks and caveats

• Revisions. Profiles first arrive in real time (R). Some are real-time adjusted (A). Months to years later, most are replaced by delayed-mode (D) versions, and the GDAC file name changes from R… to D…. Delayed-mode data can itself be reprocessed. A row reflects the GDAC version at index_date_update. Expect old rows to change between versions of this dataset.
• Real-time salinity can be wrong by drift or sensor failure even with QC 1. Some floats are on the Argo grey list (known-bad sensors). The grey list is not applied here. It is ar_greylist.txt on the GDAC.
• Primary sampling only. These rows come from the GDAC multi-profile files, so each cycle has only its primary profile. Extra samplings stored next to it in some per-profile files are not included, e.g. unpumped near-surface CTD data and high-resolution bins. In update mode, rows come from per-profile files and are cut to their first (primary) profile.
• Multi-profile vs per-profile files can differ slightly. A random check re-downloaded per-profile files and compared them with the rows. In a random check of 100 profiles, every one matched its per-profile file within sensor resolution, and 25 matched exactly. The two GDAC products sometimes disagree below sensor resolution: e.g. temperature rounded to 0.001 °C in one and not the other, or JULD stored with sub-second digits in one. All QC flags and missing-value patterns matched exactly.
• Descending profiles (direction = 'D', profile_id ending in D) exist for some floats, and the same float and cycle can also have an ascending profile. Filter direction = 'A' for the usual one-cast-per-cycle view.
• 3,846 profiles have n_levels = 0, meaning every value is missing. They are kept because they are in the GDAC index.
• 415 profiles have no valid time, mostly very early floats and test cycles. They are in argo_undated.parquet. Some profiles also lack a position (latitude null).
• Positions and times need their QC flags. 13,650 profiles have no latitude. 322 carry out-of-range sentinel positions such as -99.999 with position_qc = 9, which some DACs use for "no fix". One profile has a time in the future (2026-12-27, juld_qc = 4). Filter on position_qc and juld_qc as described above. The GDAC index sometimes gives longitude in 0–360. This dataset keeps the file's −180..180.
• Data before ~2000 come from floats that predate the formal Argo program, dating back to 1997 (earliest profile 1997-07-28).
• Pre-2012 profiles are coarse (50–120 levels). Modern floats report about 2 dbar bins (500–1000 levels).
• Other core-file parameters (e.g. conductivity CNDC) and BGC parameters (oxygen, nitrate, chlorophyll…) are not included. station_parameters lists everything the profile measured.
• Values are as reported, not interpolated to standard depths. Pressure is in decibar, roughly equal to depth in metres.

How it's kept up to date

build.py is a single uv script:

• uv run build.py full does the full rebuild from the per-float _prof.nc files. It fetches them with rsync -z in random batches of 30k profiles (0.75 GB of NetCDF; NetCDF-3 fill padding compresses ~6x on the wire). It converts each batch to staging Parquet and then deletes the raw files. Any profile whose multi-profile file is missing it, is older than the index, has an R/D mismatch, or holds a duplicate key is patched from its per-profile file. Last, it merges and sorts each shard into the layout above. ~80 GB of NetCDF are read in total. A guard stops the build if projected output passes 14 GB or disk use passes 15 GB, and the run is resumable. The original build took about 3.5 h of downloading on a busy laptop, with ~13 GB peak disk. With the current writer the final shards are ~13.3 GB, so expect a peak of ~14.5 GB; I estimated that rather than re-running.

• uv run build.py update --push is the incremental update for GitHub Actions (update-workflow.yml). It runs weekly and works like this:

  • Download the GDAC index and diff date_update and file name against sync/manifest.parquet.
  • Fetch only new or changed profiles. That means per-profile files, or the whole _prof.nc when a float has ≥50 changes, e.g. after delayed-mode reprocessing.
  • Drop profiles that left the index.
  • Rewrite only the affected shards, one at a time: download, rewrite, pre-upload, delete locally. Everything goes into one commit pinned to the parent revision.

  Weekly runs pass --defer-closed, so only the open shard changes. The first run each month applies the closed-shard revisions as well.

• Storage growth on the Hub. The Hub keeps every version of every file, but its Xet storage keeps each distinct ~64 KiB chunk only once. So an update costs only the bytes that differ from earlier versions. I replayed the last four weeks of real GDAC changes (2026-10-01 to 10-29) week by week against every shard and counted new chunks:

  policy	new bytes per 4 weeks	per year
  all shards weekly	0.74 GB	~9.7 GB
  open shard weekly, closed shards monthly (used)	0.60 GB	~7.8 GB

  Both rows also need ~1 GB/yr for the twice-yearly re-sort of the shard that closes, and ≤0.3 GB/yr for the manifest. About 1 GB/yr of the open-shard growth is genuinely new profiles. The replay ran with 64–256 KiB pages and was scaled to the 128–512 KiB setting from a two-shard comparison. Caveats: the index only records each profile's latest change, so a profile changed twice in the window counts once. Previous versions of revised rows were synthesised (earlier data mode, slightly different adjusted values). Under the previous layout (float order everywhere, fixed row groups, zstd 18), every update re-uploaded each touched shard in full: 0% chunk reuse.

• uv run build.py reconcile --spot N compares the dataset with the GDAC index (counts, missing, extra and duplicate keys, staleness, data-mode vs file-name, position/time, row order per shard) and re-downloads N random profiles to compare values.

• uv run build.py relayout rewrites local shards with the current layout rules, one shard at a time.

Reconciliation of this build

Checked against the GDAC profile index dated 2026-10-29 02:24 UTC (uv run build.py reconcile --spot 100):

check	result
profiles in index / rows in dataset / manifest rows	3,429,195 / 3,429,195 / 3,429,195
per DAC (aoml, coriolis, jma, csiro, bodc, meds, incois, csio, kma, kiost, nmdis)	all equal to the index
duplicate keys, missing, extra	0, 0, 0
rows older than the index date_update	0
index says D-mode file but data_mode ≠ D	0
position differs from the index (> 0.001°)	54 (DAC-side inconsistencies between index and file)
time differs from the index (> 1 s)	4
data_mode D / A / R	2,953,196 / 276,168 / 199,831
descending profiles	66,275
rows taken from per-profile files instead of _prof.nc	8,885 (multi-profile file stale, missing, or ambiguous)
row order matches open/closed status (argo:order)	37/37 shards (open: 2026-H2)
random per-profile re-download (100 profiles)	100/100 equal within resolution, 25/100 bit-identical

Floats: 20,656. Levels: 1.36 billion. Profile times: 1997-07-28 to the present.