The Advanced Baseline Imager (ABI) on NOAA's GOES-R series satellites scans the Americas in sixteen channels. NOAA publishes its Level 2 products to public S3 buckets, one per satellite, as NetCDF4 files: Cloud and Moisture Imagery (CMIP) one channel per file, the same imagery with all sixteen channels in one file (MCMIP), and cloud-top height, temperature, pressure, and phase. One file is one scan of one sector, with no geographic or variable subsetting.
This walkthrough pulls two scenes. The first is the channel-13 (10.3 µm
infrared) CONUS scene from GOES-18 that started nearest 12:00 UTC on 6 May
2024: it keeps the pixels the source flags as good and turns the file's scan
angles into latitude and longitude. The second is one GOES-16 mesoscale scan
later that day as a 16-band MCMIP file, stacked into a single
channels × rows × columns array. It needs usdata[netcdf] and matplotlib,
downloads about 8.3 MB, and runs in a few seconds.
from datetime import UTC, datetime
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
import xarray as xr
import usdata
from usdata import cite_lockfile, pull, verify
# One figure style for every usdata notebook, so previews look alike.
plt.rcParams.update(
{
"figure.figsize": (8, 4.5),
"figure.dpi": 120,
"axes.spines.top": False,
"axes.spines.right": False,
"axes.grid": True,
"grid.alpha": 0.3,
"font.size": 10,
}
)
manifest = Path("dataset.yaml")
print("Executed (UTC):", datetime.now(UTC).isoformat(timespec="seconds"))
print(f"usdata {usdata.__version__}; xarray {xr.__version__}; NumPy {np.__version__}")Executed (UTC): 2026-09-29T23:21:32+00:00
usdata 0.33.0; xarray 2026.7.0; NumPy 2.5.2
Select
The first source names a satellite (18), a channel (13), and the product
ABI-L2-CMIPC, the CONUS sector; there is no default satellite, and a
single-channel product has no default channel.
Rather than a window, select asks for one scene by time: the scan whose
start is nearest 12:00 UTC, the synoptic hour, within five minutes either
side, with a tie going to the lower file name. GOES-18 starts a CONUS scan
every five minutes, so the ten minutes listed hold two, and the rule keeps the
one starting at 12:01:18 over the one at 11:56:18. A start and end window
would take every scan that started in it, inclusive at both ends, and miss one
that started earlier even if it was still running. Channel 13 is infrared, so
the scene is the same by day and night.
The second source asks for ABI-L2-MCMIPM, the multi-band mesoscale product,
from GOES-16 (East). It takes no channel, since each file holds all sixteen,
and it needs a sector: GOES-16 scans two movable mesoscale sectors, M1 and M2,
each once a minute, and their files share one directory. The scan nearest
22:00 UTC, within a minute, is the one starting at 22:00:28; the one before
started at 21:59:25.
print(manifest.read_text())name: goes-abi-scenes
sources:
- name: conus-infrared
dataset: noaa:goes-abi
params:
satellite: 18
channel: 13
product: ABI-L2-CMIPC
select:
time: 2024-05-06T12:00:00Z
within: 5m
direction: nearest
- name: mesoscale-multiband
dataset: noaa:goes-abi
params:
satellite: 16
product: ABI-L2-MCMIPM
sector: M1
select:
time: 2024-05-06T22:00:00Z
within: 1m
direction: nearest
What arrives
Two NetCDF4 files, each named for the product, sector, channel where there
is one, satellite, and the scan's start, end, and creation times. The
committed dataset.lock.json pins their S3 URLs and checksums, so a pull
restores exactly these bytes without listing the archive or applying the rules
again.
result = pull(manifest)
item, multiband = result.fetched
for fetched in result.fetched:
print("File:", fetched.path.name)
print(" Bytes:", fetched.provenance.size)
print(" Source:", fetched.provenance.source_url)
print(" Checksum:", fetched.provenance.checksum)
print(" Scan:", fetched.asset.time.start.isoformat(), "to", fetched.asset.time.end.isoformat())
print("Retrieved (UTC):", item.provenance.retrieved_at.isoformat(timespec="seconds"))File: OR_ABI-L2-CMIPC-M6C13_G18_s20241271201181_e20241271203566_c20241271204061.nc
Bytes: 3821830
Source: s3://noaa-goes18/ABI-L2-CMIPC/2024/127/12/OR_ABI-L2-CMIPC-M6C13_G18_s20241271201181_e20241271203566_c20241271204061.nc
Checksum: sha256:3331dc3dcf67f3015e221484750fefebead4c51d728272045c3e31c9123a0c0a
Scan: 2024-05-06T12:01:18.100000+00:00 to 2024-05-06T12:03:56.600000+00:00
File: OR_ABI-L2-MCMIPM1-M6_G16_s20241272200280_e20241272200350_c20241272200421.nc
Bytes: 4505610
Source: s3://noaa-goes16/ABI-L2-MCMIPM/2024/127/22/OR_ABI-L2-MCMIPM1-M6_G16_s20241272200280_e20241272200350_c20241272200421.nc
Checksum: sha256:79164dd792ba339b029c20a44a5656d251ee411be63ddb8ad9b809ed2a42ae90
Scan: 2024-05-06T22:00:28+00:00 to 2024-05-06T22:00:35+00:00
Retrieved (UTC): 2026-09-29T23:21:33+00:00
Open
The NetCDF reader returns an xarray Dataset with scale, offset, and fill
values decoded and the file closed. CMI is brightness temperature in kelvin
for an infrared channel (reflectance for a visible one), and DQF is the
per-pixel quality flag; masking on it is the analysis's choice, made here by
keeping DQF == 0. Place is the geostationary fixed grid: x and y are
scan angles in radians from the satellite, described by
goes_imager_projection. Time is the scan's midpoint t, with the start and
end in the file's attributes.
scene = item.open()
cmi = scene["CMI"]
brightness = cmi.where(scene["DQF"] == 0)
projection = scene["goes_imager_projection"].attrs
print("Grid:", dict(cmi.sizes), "in", scene["x"].attrs["units"])
print("CMI:", cmi.attrs["long_name"], f"({cmi.attrs['units']})")
print("Quality flags:", scene["DQF"].attrs["flag_meanings"])
print("Good pixels:", int(brightness.count()), "of", brightness.size)
origin = projection["longitude_of_projection_origin"]
print("Projection:", projection["grid_mapping_name"], f"centred on {origin} °E")
print("Scan:", scene.attrs["time_coverage_start"], "to", scene.attrs["time_coverage_end"])
print(f"Brightness temperature: {float(brightness.min()):.1f} to {float(brightness.max()):.1f} K")Grid: {'y': 1500, 'x': 2500} in rad
CMI: ABI L2+ Cloud and Moisture Imagery brightness temperature (K)
Quality flags: good_pixel_qf conditionally_usable_pixel_qf out_of_range_pixel_qf no_value_pixel_qf focal_plane_temperature_threshold_exceeded_qf
Good pixels: 3750000 of 3750000
Projection: geostationary centred on -137.0 °E
Scan: 2024-05-06T12:01:18.1Z to 2024-05-06T12:03:56.6Z
Brightness temperature: 208.3 to 296.3 K
The reader does not reproject. The GOES-R Product User's Guide gives the conversion from scan angle to geodetic latitude and longitude, using only the projection attributes in the file. It is written as a function here because the mesoscale scene needs it too. Longitude is left continuous, so points west of the dateline are below −180.
def fixed_grid_lat_lon(ds: xr.Dataset) -> tuple[np.ndarray, np.ndarray]:
"""Latitude and longitude of every pixel, from the scan angles and projection."""
projection = ds["goes_imager_projection"].attrs
r_eq = projection["semi_major_axis"]
r_pol = projection["semi_minor_axis"]
height = projection["perspective_point_height"] + r_eq
x, y = np.meshgrid(ds["x"].values.astype(float), ds["y"].values.astype(float))
a = np.sin(x) ** 2 + np.cos(x) ** 2 * (np.cos(y) ** 2 + (r_eq / r_pol) ** 2 * np.sin(y) ** 2)
b = -2 * height * np.cos(x) * np.cos(y)
c = height**2 - r_eq**2
distance = (-b - np.sqrt(b**2 - 4 * a * c)) / (2 * a)
sx = distance * np.cos(x) * np.cos(y)
sy = -distance * np.sin(x)
sz = distance * np.cos(x) * np.sin(y)
lat = np.degrees(np.arctan((r_eq / r_pol) ** 2 * sz / np.sqrt((height - sx) ** 2 + sy**2)))
lon = projection["longitude_of_projection_origin"] - np.degrees(np.arctan(sy / (height - sx)))
return lat, lon
def file_extent(ds: xr.Dataset) -> str:
"""The bounds the file states for itself, in the same units as the computed ones."""
extent = ds["geospatial_lat_lon_extent"].attrs
return (
f"{extent['geospatial_southbound_latitude']:.2f} to "
f"{extent['geospatial_northbound_latitude']:.2f} °N, "
f"{extent['geospatial_westbound_longitude']:.2f} to "
f"{extent['geospatial_eastbound_longitude']:.2f} °E"
)
lat, lon = fixed_grid_lat_lon(scene)
print(f"Computed: {lat.min():.2f} to {lat.max():.2f} °N, {lon.min():.2f} to {lon.max():.2f} °E")
print("File says:", file_extent(scene))Computed: 14.57 to 53.50 °N, -184.38 to -89.62 °E
File says: 14.57 to 53.50 °N, 175.62 to -89.62 °E
The MCMIP file opens the same way, on the same kind of fixed grid. Instead of
one CMI and one DQF it has CMI_C01 to CMI_C16 and DQF_C01 to
DQF_C16, all on the 2 km grid, so the 0.5 km and 1 km visible channels
arrive already coarsened. Stacking the sixteen masked layers by name gives
one channels × rows × columns array, the shape an image model takes, with no
regridding. Channels 1 to 6 are reflectance factor and 7 to 16 brightness
temperature in kelvin; the file's band_wavelength_C01 to _C16 give each
channel's central wavelength.
multi = multiband.open()
channels = range(1, 17)
stack = np.stack(
[multi[f"CMI_C{c:02d}"].where(multi[f"DQF_C{c:02d}"] == 0).values for c in channels]
)
print("Stack:", stack.shape, "on the", multi.attrs["spatial_resolution"], "grid")
print("Scene:", multi.attrs["scene_id"], "sector,", multi.attrs["dataset_name"].split("_")[1])
print("File says:", file_extent(multi))
print("Scan:", multi.attrs["time_coverage_start"], "to", multi.attrs["time_coverage_end"])
for c, layer in zip(channels, stack, strict=True):
wavelength = float(multi[f"band_wavelength_C{c:02d}"].values.item())
units = multi[f"CMI_C{c:02d}"].attrs["units"]
print(
f"C{c:02d} {wavelength:5.2f} µm units {units} "
f"good {np.isfinite(layer).mean():6.1%} median {np.nanmedian(layer):8.3f}"
)Stack: (16, 500, 500) on the 2km at nadir grid
Scene: Mesoscale sector, ABI-L2-MCMIPM1-M6
File says: 29.72 to 43.40 °N, -110.37 to -91.05 °E
Scan: 2024-05-06T22:00:28.0Z to 2024-05-06T22:00:35.0Z
C01 0.47 µm units 1 good 100.0% median 0.225
C02 0.64 µm units 1 good 100.0% median 0.177
C03 0.87 µm units 1 good 100.0% median 0.275
C04 1.38 µm units 1 good 100.0% median 0.002
C05 1.61 µm units 1 good 100.0% median 0.211
C06 2.25 µm units 1 good 100.0% median 0.171
C07 3.89 µm units K good 100.0% median 299.120
C08 6.17 µm units K good 100.0% median 241.055
C09 6.93 µm units K good 100.0% median 250.407
C10 7.34 µm units K good 100.0% median 260.014
C11 8.44 µm units K good 100.0% median 284.965
C12 9.61 µm units K good 100.0% median 255.425
C13 10.33 µm units K good 100.0% median 287.746
C14 11.19 µm units K good 100.0% median 287.473
C15 12.27 µm units K good 100.0% median 285.354
C16 13.27 µm units K good 100.0% median 270.503
A first look
The scene on latitude and longitude, cold cloud tops white, with the 235 K contour, a threshold often used for deep convective cloud, in orange. The plot draws every fourth pixel; the numbers below use every good pixel.
every = slice(None, None, 4)
fig, ax = plt.subplots(layout="constrained")
mesh = ax.pcolormesh(
lon[every, every],
lat[every, every],
brightness.values[every, every],
cmap="Greys",
vmin=200,
vmax=300,
shading="auto",
rasterized=True,
)
ax.contour(
lon[every, every],
lat[every, every],
brightness.values[every, every],
levels=[235],
colors="#c2410c",
linewidths=0.6,
)
fig.colorbar(mesh, ax=ax, label="Brightness temperature (K)")
start = item.asset.time.start
ax.set(
xlabel="Longitude (°E)",
ylabel="Latitude (°N)",
title=f"GOES-18 channel 13 CONUS scene, {start.day} {start:%B %Y %H:%M} UTC",
)
plt.show()
values = brightness.values
cold = values < 235
coldest = np.nanargmin(values)
print(f"Pixels colder than 235 K: {cold.mean():.1%} of the scene")
print(
f"Coldest pixel: {values.flat[coldest]:.1f} K at "
f"{lat.flat[coldest]:.1f} °N, {lon.flat[coldest]:.1f} °E"
)
print(f"Warmest pixel: {np.nanmax(values):.1f} K")Pixels colder than 235 K: 3.9% of the scene
Coldest pixel: 208.3 K at 19.4 °N, -111.6 °E
Warmest pixel: 296.3 K
GOES-18 is GOES-West, and its "CONUS" sector is centred on 137°W: it covers the eastern Pacific and the western United States, and its eastern edge is near 90°W. Most of the scene is warm: clear sky or low cloud. The cold, high cloud sits in three corners: over the northern Rockies and southern Canada, south of the Aleutians, and over the Pacific off western Mexico, which holds the coldest pixel.
Three of the sixteen layers of the mesoscale stack, on the scan grid with north up: red visible reflectance, upper-level water vapour, and the same infrared window as the CONUS scene.
mstart = multiband.asset.time.start
fig, axes = plt.subplots(1, 3, figsize=(10, 3.6), layout="constrained")
panels = [
(2, "C02 0.64 µm visible", "Greys_r", 0, 1, "Reflectance factor"),
(8, "C08 6.2 µm water vapour", "Blues", 200, 260, "Brightness temperature (K)"),
(13, "C13 10.3 µm infrared", "Greys", 200, 300, "Brightness temperature (K)"),
]
for ax, (c, title, cmap, low, high, label) in zip(axes, panels, strict=True):
image = ax.imshow(stack[c - 1], cmap=cmap, vmin=low, vmax=high)
ax.set(title=title, xticks=[], yticks=[])
ax.grid(False)
fig.colorbar(image, ax=ax, shrink=0.85, label=label)
fig.suptitle(f"GOES-16 M1 mesoscale scan, {mstart.day} {mstart:%B %Y %H:%M:%S} UTC")
plt.show()
mlat, mlon = fixed_grid_lat_lon(multi)
infrared, visible = stack[12], stack[1]
coldest = np.nanargmin(infrared)
cold = infrared < 235
print(f"Pixels colder than 235 K: {cold.mean():.1%} of the sector")
print(
f"Coldest pixel: {infrared.flat[coldest]:.1f} K at "
f"{mlat.flat[coldest]:.1f} °N, {mlon.flat[coldest]:.1f} °E"
)
print(
f"Median C02 reflectance: {np.nanmedian(visible[cold]):.2f} where colder than 235 K, "
f"{np.nanmedian(visible[~cold]):.2f} elsewhere"
)Pixels colder than 235 K: 9.8% of the sector
Coldest pixel: 207.2 K at 38.0 °N, -98.8 °E
Median C02 reflectance: 0.50 where colder than 235 K, 0.14 elsewhere
In this scan a band of deep cloud runs southwest to northeast from the middle of the sector to its northern edge. It is bright in the visible channel and cold in the infrared window, and the water-vapour channel, which sees the upper troposphere rather than the ground, shows the same anvils. 9.8% of the sector is colder than 235 K, and the coldest pixel, 207.2 K, is in Kansas. Because the sixteen layers share one grid, a question across channels is an index into the stack: the median visible reflectance is 0.50 under the cold cloud and 0.14 elsewhere. The visible values are the file's reflectance factor, which is multiplied by the cosine of the solar zenith angle, so a late-afternoon scene reads darker than a midday one.
Pin and cite
verify checks the cached files against the lockfile's checksums. Keep the
manifest and lockfile with your analysis; the citation below is what a
methods section needs, and usdata cite dataset.yaml prints the same.
assert verify(manifest) == []
for citation in cite_lockfile(manifest):
print(citation.as_text())noaa:goes-abi
NOAA Geostationary Operational Environmental Satellites (GOES) 16, 17, 18 & 19 was accessed on 2026-09-29 from https://registry.opendata.aws/noaa-goes
homepage: https://registry.opendata.aws/noaa-goes/
license: US Government Work (public domain)
terms: https://www.noaa.gov/information-technology/open-data-dissemination
retrieved: 2026-09-29; 2 checksummed assets (8,327,440 bytes) pinned by usdata 0.33.0
sources: conus-infrared, mesoscale-multiband
What was awkward
- Selecting one scene used to mean knowing its start to the tenth of a second
(
12:01:18.1Z), which came from listing the archive first, since a window of a few minutes returns every scan that started in it. The manifest now asks for the scan nearest a time withselect. - "CONUS" depends on the satellite. GOES-18's sector is the Pacific-centred West view, which misses the central and eastern states; for Oklahoma or anything east of about 90°W, ask for GOES-16 or GOES-19.
- The file places pixels by scan angle, and the reader does not reproject. Latitude and longitude take the dozen lines above, and a map with coastlines or state lines needs a mapping library that is not an extra.
- The sector runs past the dateline, so longitude is either continuous below −180 or wraps to +175; code that assumes −180 to 180 splits the scene.
- Quality masking is the analysis's job. In these scenes every pixel is flagged good, which will not be true of every scene or channel.
- Channel 13 brightness temperature is the temperature of whatever the sensor sees, cloud top or ground, not surface air temperature.
- The MCMIP file has no channel dimension: sixteen
CMI_Cnnand sixteenDQF_Cnnvariables, plus per-channel statistics, so the stack is built by name. Its 2 km grid coarsens channels 1 to 3; for those at full resolution, fetch the single-channel files. - A mesoscale sector is wherever NOAA pointed it that day. Only the opened file says where it is, so a query cannot ask for a place, and the same sector name covers different ground on other days.
See the GOES ABI guide for satellites, products, sectors, and window limits, and the mesoscale study for a sequence of one-minute scenes.

