usdata

NOAA · GOES-R ABI Imagery and Cloud-Top Products

GOES ABI imagery, multiband scenes, and cloud-top products

ABI Level 2 products from GOES-16, 17, 18, and 19 in anonymous NOAA S3 buckets: single-channel (ABI-L2-CMIP) and 16-band (ABI-L2-MCMIP) Cloud and Moisture Imagery, and cloud-top height (ACHA), temperature (ACHT), pressure (CTP), and phase (ACTP), each in the CONUS, full-disk, and M1/M2 mesoscale sectors NOAA produces it for.

NetCDF4Since v0.8
The walkthrough's first look at goes abi imagery, multiband scenes, and cloud-top products

At a glance

Spatial
Imagery 0.5 km to 2 km at nadir by band, MCMIP bands on the 2 km grid; cloud-top products 2 km to 10 km at nadir
Time step
CONUS every 5 minutes; full disk every 10 minutes in Mode 6 (15 in Mode 3, 5 in Mode 4); two mesoscale sectors every 60 seconds or one every 30 seconds
Updates
New data is added as soon as it's available
Files
NetCDF4
Selection
Whole scenes of one ABI product by inclusive UTC scan-start time, with one channel or mesoscale sector where the product has them
You provide
Satellite and both timestamps; product (default ABI-L2-CMIPC); channel for CMIP products; sector for mesoscale products
Longest request
7 days
Full description

ABI Level 2 products from GOES-16, 17, 18, and 19 in anonymous NOAA S3 buckets: single-channel (ABI-L2-CMIP) and 16-band (ABI-L2-MCMIP) Cloud and Moisture Imagery, and cloud-top height (ACHA), temperature (ACHT), pressure (CTP), and phase (ACTP), each in the CONUS, full-disk, and M1/M2 mesoscale sectors NOAA produces it for. Select an explicit satellite, one product directory, a scan-start interval, a channel for single-channel imagery, and M1 or M2 for mesoscale; each asset is a complete NetCDF scene with no geographic or variable subsetting.

Quick start

Terminal

python -m pip install "usdata[netcdf]"
usdata fetch noaa:goes-abi \
  --start 2024-05-06T11:55:00Z \
  --end 2024-05-06T12:05:00Z \
  -p satellite=18 \
  -p channel=13 \
  -p product=ABI-L2-CMIPC
# fetch takes every file that starts in this window; the manifest keeps only
# the one starting nearest 2024-05-06T12:00:00Z.

Python

from datetime import datetime, timedelta

from usdata import build_query, fetch, get, select_by_time

items = fetch(
    get("noaa:goes-abi"),
    build_query(
        start="2024-05-06T11:55:00Z",
        end="2024-05-06T12:05:00Z",
        satellite=18,
        channel=13,
        product="ABI-L2-CMIPC",
    ),
)
chosen = select_by_time(
    [item.asset for item in items],
    target=datetime.fromisoformat("2024-05-06T12:00:00Z"),
    tolerance=timedelta(seconds=300),
    direction="nearest",
).asset
data = next(item for item in items if item.asset == chosen).open()

Manifest

# dataset.yaml, then: usdata pull dataset.yaml
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

The same query the walkthrough below ran. The netcdf extra opens the files.

Saved results from a run against the live service; the notebook records when it ran and the checksums of what it read. Run it yourself.

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()
Saved plot from GOES ABI imagery, multiband scenes, and cloud-top products
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()
Saved plot from GOES ABI imagery, multiband scenes, and cloud-top products
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 with select.
  • "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_Cnn and sixteen DQF_Cnn variables, 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.

Used in these studies

What did radar and satellites show around a reported tornado?

Connect one Storm Events report to nearby NEXRAD and GOES observations, with explicit time matching and a plotted event context.

Storm Events details, fatalities, and locations · NEXRAD radar scans · GOES ABI imagery, multiband scenes, and cloud-top products

Reference

Cite as NOAA Geostationary Operational Environmental Satellites (GOES) 16, 17, 18 & 19 was accessed on [date] from https://registry.opendata.aws/noaa-goes