Do I need Python installed to use NetCDF Studio?

No. The web app handles everything in the cloud with no local installation required. Python 3.9 or later is only needed if you run a Compute Node to add your own processing capacity.

What is a Compute Node in NetCDF Studio?

A compute node is a secondary machine you connect to your NetCDF Studio server to add processing capacity. It runs the netcdf-studio-node agent, which dials out to the server and receives jobs over WebSocket. No port forwarding is required.

Welcome to NetCDF Studio

Q: What file formats can I upload to NetCDF Studio?

NetCDF Studio accepts .zip archives containing NetCDF (.nc) files. For ERA5 and CMIP6, no upload is needed — the server fetches data directly from the Copernicus CDS or Google Earth Engine.

Q: What data sources does NetCDF Studio support?

Three sources are available: Upload Archive (your own IMDAA ZIP files), ERA5 (Copernicus Climate Data Store), and CMIP6 (NASA NEX-GDDP via Google Earth Engine). Each source feeds into the same CSV processing pipeline.

Q: What is the maximum upload size?

Uploads are capped at 500 MB on the free tier and 2 GB on Pro and Max plans. Enterprise upload limits are negotiated per account. For larger archives, run NetCDF Studio locally — the CLI and Python tools process files of any size on your own computer.

Q: Does NetCDF Studio charge for external data retrieval?

No. ERA5 data from the Copernicus CDS is free. GEE/CMIP6 usage is billed by Google to your GEE account. Your NetCDF Studio plan covers server-side computation only.

Q: How long is data retained in NetCDF Studio?

Processed files are retained according to your membership plan's data retention policy. Job scratch data on Compute Nodes is deleted immediately after each job completes. You can delete files at any time from the Files page to free up storage.

Your guide to converting climate reanalysis and projection data into research-ready CSV datasets.

What Can You Do?

Upload & Convert

Upload IMDAA ZIP archives and convert them into structured CSV files with live progress tracking.

Fetch ERA5 Data

Download ERA5 reanalysis directly from the Copernicus Climate Data Store — no file upload needed.

Apply Corrections

Run scientific correction engines on your CSV data — temperature, radiation, humidity, wind speed, and more.

Convert Units

Transform units across your datasets — Kelvin to Celsius, W/m² to MJ/m², and other scientific conversions.

Supported Data Sources

NetCDF Studio provides guided workflows for six major climate data sources. Each page explains the dataset, access requirements, and how the conversion works.

NetCDF → CSV

Convert any NetCDF file to flat CSV. Works with any gridded climate dataset in NetCDF-3 or NetCDF-4 format.

IMDAA

Indian Monsoon Data Assimilation and Analysis — 12 km reanalysis from NCMRWF, 1979 to near-present.

ERA5

Global reanalysis from ECMWF via Copernicus CDS. 0.25° resolution, 1940 to near-present. Bring your own token.

CMIP6

Coupled model projections under SSP1-2.6, SSP2-4.5, SSP3-7.0 and SSP5-8.5 scenarios out to 2100.

AWS Open Data

NOAA GOES, GFS, NASA MERRA-2 and GLDAS from public S3 buckets. No AWS account required.

ESGF

Full Earth System Grid Federation catalogue — CMIP6, CORDEX regional projections, CMIP5, and more.

Uploading Archives

How to upload IMDAA reanalysis ZIP files for conversion. For ERA5 or CMIP6 data, see the dedicated pages.

Step-by-Step

1

Go to the Dashboard

Sign in to your account and navigate to the Home page. You'll see the upload area at the center of the screen.

2

Select Your Archive

Drag and drop your IMDAA .zip archive onto the upload zone, or click to browse. The file must contain NetCDF (.nc) files from IMDAA reanalysis datasets.

3

Configure & Submit

After the archive is inspected, you can choose your output format and variable selections. Click Submit to begin processing.

4

Download Results

Track progress in the Process page. Once complete, download your CSV files directly from the dashboard.

💡

You can re-use previously uploaded archives. Go to the upload step and select from your existing archive list instead of uploading again.

Tracking Requests

Monitor your conversion jobs in real time.

Request Statuses

Status	Meaning
Queued	Your request is waiting to be processed.
Processing	The server is actively converting your archive. You'll see a live progress bar.
Completed	All CSV files are ready for download.
Failed	Something went wrong. Check the error message and try again.

What You Can Do

View Progress — Live percentage and ETA updates as your job runs.
Download Files — Once complete, download individual CSVs or all at once.
Delete Requests — Remove completed or failed requests from your history.
Re-run — Use the same archive to create new CSV variants with different settings.

Correction Engines

Apply scientific correction pipelines to your processed CSV data.

What Are Correction Engines?

IMDAA provides raw 3-hourly reanalysis data. Correction engines transform this raw data into daily, scientifically standardized products that are ready for research — converting units, aggregating timesteps, and applying domain-specific formulas.

How to Apply Corrections

1

Navigate to Corrections

Go to the Corrections page from the sidebar menu.

2

Select a Source File

Choose a processed CSV from your completed requests. The system will show which correction modules are compatible with your data.

3

Choose a Module

Select the correction engine to apply. Each module shows what it does and what outputs you'll receive.

4

Review & Download

Once processing completes, preview the results and download the corrected CSV files.

Available Modules

Module	What It Does	Output
🌡️ Temperature	Converts 3-hourly Kelvin data to daily °C products	Tmean, Tmax, Tmin
☀️ Radiation	Integrates W/m² flux into daily energy totals	SW, LW, Net Radiation (MJ/m²/day)
💧 Relative Humidity	Converts fractional RH to daily percentage stats	RH mean, max, min (%)
☁️ Vapor Pressure	Derives actual vapor pressure from dewpoint	ea (kPa)
🌬️ Wind Speed	Computes magnitude from U/V components at 2m height	Daily mean wind speed (m/s)
🌧️ Rainfall Erosivity	Estimates R-factor from sub-daily rainfall	Erosivity index (MJ·mm/ha/hr)
🌱 Soil Moisture	Processes 4-layer Noah LSM soil moisture data	Layer-wise daily mean, SWS (mm), Root Zone, Surface

Unit Conversion

Transform units across your CSV datasets with built-in scientific formulas.

How to Use

1

Open the Unit Converter

Navigate to the Unit Conversion page from the sidebar. You'll see the converter interface.

2

Upload Your CSV

Upload a processed CSV file. The system reads the columns and lets you select which ones to convert.

3

Choose Conversions

Select the source unit and target unit for each column. The formula used is shown transparently so you can verify the transformation.

4

Download Converted CSV

Click Download to get your unit-converted CSV with standardized column names and clear unit labels.

Common Conversions

From	To	Formula
Kelvin (K)	Celsius (°C)	T(°C) = T(K) − 273.15
W/m²	MJ/m²/day	E = flux × 0.0864
Pa	kPa	P(kPa) = P(Pa) / 1000
m/s	km/h	v(km/h) = v(m/s) × 3.6
kg/m²/s	mm/day	P(mm) = P(kg/m²/s) × 86400

File Management

Organize, download, and manage your processed archives and CSV outputs.

Your Workspace

The Files page shows all your archives and their associated outputs organized by upload. Each archive can have multiple CSV variants from different processing runs.

What You Can Do

Download — Download individual CSV files or all outputs from an archive at once.
Preview — Quick-view the first rows of any CSV to verify the data before downloading.
Re-process — Select an existing archive and run it again with different settings.
Delete — Remove files you no longer need to free up storage.

💡

Your storage quota depends on your membership plan. Check your Account page to see how much storage you have remaining.

Scientific Modules Reference

How each correction module transforms your IMDAA data.

🌡️ Temperature

Converts 3-hourly temperatures from Kelvin to Celsius, then produces daily aggregates.

UNIT CONVERSION

T(°C) = T(K) − 273.15

Products: Tmean (daily mean), Tmax (daily maximum), Tmin (daily minimum).

☀️ Radiation

Integrates instantaneous flux values (W/m²) into daily energy totals (MJ/m²/day).

FLUX INTEGRATION

R_daily = Σ(i=1 to 8) [ R_i × 0.03888 ]
where 0.03888 = 10800 seconds / 10⁶ (J → MJ)

Products: Net Shortwave, Net Longwave, Net Radiation.

💧 Relative Humidity

Converts fractional RH (0–1) to percentage and computes daily statistics.

CONVERSION

RH(%) = RH(fraction) × 100

Products: RH mean, RH max, RH min.

☁️ Vapor Pressure

Derives actual vapor pressure from dewpoint temperature using the Magnus formula.

MAGNUS FORMULA

ea = 0.6108 × exp[ (17.27 × Td) / (Td + 237.3) ]

Products: Daily mean actual vapor pressure (kPa).

🌬️ Wind Speed

Computes wind speed from U and V vector components with FAO-56 height adjustment.

VECTOR MAGNITUDE + HEIGHT ADJ.

WS = √(U² + V²)
WS_2m = WS_z × [ 4.87 / ln(67.8z − 5.42) ]

Products: Daily mean wind speed at 2m (m/s).

🌧️ Rainfall Erosivity

Estimates the R-factor (erosive potential) from sub-daily rainfall intensity.

R-FACTOR

R = Σ(EI₃₀) where EI₃₀ = kinetic energy × max 30-min intensity

Products: Daily precipitation (mm), Erosivity index.

🌱 Soil Moisture

Processes 4-layer Noah LSM soil moisture data (m³/m³) to compute layer-wise daily means, total soil water storage, and root zone averages.

SOIL WATER STORAGE

SWS = Σ(θᵢ × Zᵢ) → mm of water
Layers: L1 (0–10cm, 100mm) · L2 (10–35cm, 250mm) · L3 (35–100cm, 650mm) · L4 (100–300cm, 2000mm)

ROOT ZONE MOISTURE

θ_root = (θ₁×Z₁ + θ₂×Z₂ + θ₃×Z₃) / (Z₁ + Z₂ + Z₃) → m³/m³

Products: Layer-wise daily mean, Total SWS (mm), Root Zone moisture (0–1 m), Surface layer (0–10 cm), Monthly summaries.

Build Custom Correction Engines

Create your own scientific correction modules and share them with the research community.

🔧

Custom engines let you define your own scientific pipeline — input variables, formulas, output schema, and documentation — all uploadable from the Corrections page in the dashboard.

What You Need

Every custom correction module requires two files:

File	Format	Purpose
logic.py	Python (.py)	The processing script with your scientific logic
theory.md	Markdown (.md)	Scientific documentation shown to users in the wizard

Input File Requirements

Your module will receive a processed IMDAA CSV file. These CSVs always contain:

Column	Type	Description
`lat`	Float	Latitude coordinate
`lon`	Float	Longitude coordinate
`time`	Datetime	Timestamp of the observation
`station`	String	Station name or ID
`height`	Float	Station elevation (m)
`grid`	String	Grid cell identifier
`loc_id`	String	Location identifier (lat_lon)
Variable columns	Float	The actual data values (e.g., temperature, wind speed)

Variable Mapping & Unit Conversion Flow

Before your apply_correction() runs, the engine performs two preprocessing steps automatically:

1

Column Mapping

The user maps each of your REQUIRED_VARIABLES to a CSV column. The engine sends the column indices (0-based) to the Python worker. Your module receives only the mapped columns plus the standard metadata columns (lat, lon, time, station, height, grid, loc_id, date).

2

Unit Conversion

If the user specifies source → target unit conversions (e.g., Kelvin → Celsius), the engine applies the conversion formula before calling your apply_correction(). Your function receives already-converted data. You do not need to handle unit conversion in your logic.

The complete data flow from user input to your function:

/* Data preprocessing pipeline */ User selects CSV file → User maps REQUIRED_VARIABLES to CSV columns (by index) → User sets source unit → target unit for each variable → Engine selects mapped columns from DataFrame → Engine applies unit formulas (e.g., "x - 273.15" for K→°C) → Engine generates loc_id column from lat/lon if missing → Engine calls apply_correction(df, frequency, aggregations, output_prefix, transpose) → Your function receives the converted DataFrame

💡

The "original" baseline option gives the user access to the pre-conversion data, while "converted" gives the post-conversion data. Both are handled by the engine — your module only sees the converted data.

Python Script Structure

Your logic.py must define two things:

1. Metadata Constants

These tell the UI what your module needs and what it produces:

# Variables the user must map from their CSV REQUIRED_VARIABLES = ["Temperature", "Dewpoint"] # Output schema — what the module produces AGGREGATION_SCHEMA = { "baseline": { "options": [ {"id": "original", "label": "Original Values", "default": True} ] }, "correctionOutputs": { "note": "Optional description shown in the wizard", "aggregations": [ { "temporal": "sub-daily", "label": "Sub-Daily", "defaultEnabled": False, "types": [ {"id": "instant", "label": "Instantaneous Value", "default": True} ] }, { "temporal": "daily", "label": "Daily", "defaultEnabled": True, "types": [ {"id": "mean", "label": "Daily Mean", "default": True}, {"id": "max", "label": "Daily Max", "default": False}, {"id": "min", "label": "Daily Min", "default": False} ] }, { "temporal": "monthly", "label": "Monthly", "defaultEnabled": False, "types": [ {"id": "mean", "label": "Monthly Mean", "default": True} ] } ] } }

2. How the Output Selection Plan Works

When a user selects your module in the correction wizard, the Output Selection Plan section is dynamically generated from your AGGREGATION_SCHEMA. This means the checkboxes, group labels, and default states are entirely driven by what you define — no UI code changes are needed.

Data Flow

/* How the schema reaches the UI */ Python AGGREGATION_SCHEMA constant → inspect_module.py extracts it at server boot → Cached in server settings (sysSettings.corrections[].aggregationSchema) → Served via GET /api/settings/public → Frontend renderAggregations(schema) generates DOM checkboxes

Schema Structure Breakdown

Field	Level	Purpose
`baseline.options`	Root	Defines baseline checkboxes (e.g., "Original Values", "Unit Converted"). Each option has `id`, `label`, and `default` (checked state).
`correctionOutputs.note`	Root	A descriptive string shown above the aggregation checkboxes (e.g., "Temperature Product Suite: Generates Tmax, Tmin, Tmean").
`aggregations[]`	Output group	Each entry defines a temporal group (row of checkboxes).
`temporal`	Group	The temporal key — `"sub-daily"`, `"daily"`, `"monthly"`, or `"yearly"`. This value is passed to `apply_correction()` in the `aggregations` payload.
`label`	Group	Display label for the group (e.g., "DAILY PRODUCTS", "Monthly").
`defaultEnabled`	Group	If `true`, the group's checkboxes are checked by default. If `false` or omitted, they start unchecked.
`types[]`	Group	Individual output checkboxes within the group.
`types[].id`	Type	Unique identifier for the output type (e.g., `"max"`, `"sws"`). This `id` is what your `apply_correction()` receives in the `aggregations` payload.
`types[].label`	Type	User-visible label (e.g., "Tmax (Max)", "Total Soil Water Storage (mm)").
`types[].default`	Type	If `true`, this checkbox starts checked.

Supported Temporal Values

Value	Use Case	Example
`"sub-daily"`	Instantaneous or same-resolution outputs	10m wind speed from hourly U/V
`"daily"`	Daily aggregations (mean, max, min, sum)	Daily mean temperature
`"monthly"`	Monthly summaries	Monthly mean soil water storage
`"yearly"`	Annual summaries	Mean annual erosivity
`"none"`	Baseline only (no temporal grouping)	Original or unit-converted data

What the User's Selection Becomes

When the user clicks Execute Pipeline, the checked checkboxes are collected into an aggregations array and sent to apply_correction():

// If user checks: Daily → Tmax, Tmin | Monthly → Tmean aggregations = [ { "temporal": "daily", "types": ["max", "min"] }, { "temporal": "monthly", "types": ["avg"] } ]

Your apply_correction() function iterates over this array to produce the requested outputs. The temporal and types[].id values are what you defined in your schema — they are the contract between your UI declaration and your processing logic.

💡

If no AGGREGATION_SCHEMA is defined, the system falls back to a default schema with a single "none" temporal group producing "original" and "converted" baseline outputs.

3. The apply_correction Function

This is the entry point the engine calls with the user's mapped data:

# This function is called by the engine def apply_correction(df, frequency="hourly", aggregations=None, output_prefix="Output", transpose=True, **kwargs): """ df: Pandas DataFrame with metadata + mapped columns frequency: Data frequency ("hourly", "3hourly", "daily") aggregations: List of user-selected outputs from AGGREGATION_SCHEMA output_prefix: Prefix for output filenames (default: "Output") transpose: If True, pivots output to station-per-column format """ # 1. Get variable columns (everything except metadata) _META = {"lat", "lon", "time", "station", "height", "grid", "loc_id", "date"} var_cols = [c for c in df.columns if c.lower() not in _META] # 2. Validate required variables exist if len(var_cols) < 1: return {"error": "No variable columns found"} # 3. Your scientific computation here result = df[var_cols].mean() # Example # 4. Return a dict of filename → DataFrame return { f"{output_prefix}_Daily_Mean.csv": result_df }

Output Schema

Your function must return a dictionary where:

Keys = output filenames (e.g., "Daily_Mean.csv")
Values = Pandas DataFrames with the computed results

Each DataFrame should include lat, lon, date columns plus your computed values. The engine handles storage and download links automatically.

Output File Naming Convention

Every correction run generates one or more CSV files. Understanding the naming convention helps you identify outputs programmatically and build downstream automation.

How Filenames Are Resolved

The engine uses a two-stage resolution process to produce final filenames:

1

Your apply_correction() returns a dict

Each dict key is either a complete filename (ending in .csv) or a suffix (without .csv). The engine treats these differently.

2

write_results() resolves the final name

If the key ends with .csv → used as-is (e.g., "Output_Tmax_Daily.csv")
If the key does not end with .csv → the engine prepends {output_prefix}_ and appends .csv (e.g., "Daily_Mean" becomes "Output_Daily_Mean.csv")

Baseline Output Names

Baseline outputs are generated automatically by the engine (not by your module):

Baseline Option	Filename
`"original"`	`{output_prefix}_Original.csv`
`"converted"`	`{output_prefix}_UnitConverted.csv`

Built-in Module Naming Patterns

The table below shows the naming convention used by each built-in module, so you know what to expect when running them:

Module	Dict Key Pattern	Final Filename Example	Has .csv in key?
Temperature	`{prefix}_{Label}_{Temporal}.csv`	`Output_Tmax_Daily.csv`	Yes
Relative Humidity	`{prefix}_{Label}_{Temporal}.csv`	`Output_RHmean_Daily.csv`	Yes
Radiation	`{prefix}_{Product}_Daily_MJ.csv`	`Output_NetSW_Daily_MJ.csv`	Yes
Rainfall Erosivity	`{prefix}_{Product}_{Temporal}.csv`	`Output_Rainfall_Daily.csv`	Yes
Soil Moisture	`{prefix}_{Product}_{Temporal}`	`Output_SoilWaterStorage_Daily.csv`	No — engine adds .csv
Wind Speed	`{Product}`	`Output_Daily_Wind_Speed_10m.csv`	No — engine adds prefix + .csv
Vapor Pressure	`{Product}`	`Output_Daily_Saturation_Vapor_Pressure_ES.csv`	No — engine adds prefix + .csv

Recommended Pattern for Custom Modules

For consistency with the built-in modules, we recommend including both output_prefix and .csv in your dict keys. This makes filenames predictable and self-documenting:

# Recommended: include prefix + .csv in the key return { f"{output_prefix}_Daily_Mean.csv": daily_df, f"{output_prefix}_Monthly_Sum.csv": monthly_df, }

ℹ️

The output_prefix comes from the user's "Output Prefix" field in the wizard (defaults to "Output"). If multiple files are generated, each gets its own name — no index suffixes are added by the engine.

Transpose Output Format

The transpose parameter controls the output format:

transpose=True (default): Output is pivoted — rows are timestamps, columns are station/location IDs. Best for time-series analysis.
transpose=False: Output is in long format — each row is a single observation with lat, lon, time, and value columns.

ℹ️

The engine automatically handles the loc_id column creation from lat/lon coordinates when needed for grouping.

Error Handling

To signal errors, return a dictionary with an "error" key:

if len(var_cols) < 2: return {"error": "Wind Speed module requires both U and V components."}

The engine will catch this and display the error message to the user instead of generating output files.

Writing Theory Documentation

The theory.md file is shown to users in the correction wizard. It should include:

1

Overview

What the module does, which variables it processes, and what scientific products it generates.

2

Calculation Logic

The formulas used. Use LaTeX notation: $$ T(°C) = T(K) - 273.15 $$

3

Expected Outputs

List every output file the module can generate, with column names and units.

Getting Started Template

Copy this starter template and modify it for your use case:

# my_custom_module/logic.py import pandas as pd import numpy as np REQUIRED_VARIABLES = ["MyVariable"] AGGREGATION_SCHEMA = { "baseline": { "options": [ {"id": "original", "label": "Original Data", "default": True} ] }, "correctionOutputs": { "aggregations": [ { "temporal": "daily", "label": "Daily Products", "defaultEnabled": True, "types": [ {"id": "daily_mean", "label": "Daily Mean", "default": True} ] } ] } } def apply_correction(df, frequency="hourly", aggregations=None, output_prefix="Output", transpose=True, **kwargs): # Extended metadata columns _META = {"lat", "lon", "time", "station", "height", "grid", "loc_id", "date"} var_cols = [c for c in df.columns if c.lower() not in _META] # Validate required variables if not var_cols: return {"error": "No variable columns found"} # Parse time and create location ID df = df.copy() df["time"] = pd.to_datetime(df["time"]) df["loc_id"] = df["lat"].round(4).astype(str) + "_" + df["lon"].round(4).astype(str) # Pivot for time-series operations ts_pivot = df.pivot_table(index="time", columns="loc_id", values=var_cols[0]) # Compute daily mean daily = ts_pivot.resample("D").mean() # Format output based on transpose flag if not transpose: daily = daily.reset_index().melt(id_vars="time", var_name="loc_id", value_name="MyVariable_daily_mean") daily[["lat", "lon"]] = daily["loc_id"].str.split("_", expand=True).astype(float) daily = daily.drop(columns=["loc_id"]) return {f"{output_prefix}_Daily_Mean.csv": daily}

How to Upload

1

Go to Corrections Page

Navigate to Corrections in the dashboard sidebar.

2

Fill in Module Details

Enter a label (e.g., "Bias Correction v2"), upload your logic.py and theory.md files.

3

Share (Optional)

Check "Share with Community" to make your module available in the global research library for other users.

4

Upload

Click Upload Module. Your module will appear in the correction engine dropdown immediately.

⚠️

Your Python script runs in a sandboxed environment. Only pandas, numpy, and scipy are available. If you need additional packages, contact the admin.

Google Earth Engine

Fetch satellite and climate datasets from Google Earth Engine directly into your processing jobs.

ℹ️

GEE integration is available on Pro and Max plans. You must hold your own Google Earth Engine account — NetCDF Studio does not provide GEE access.

What Is GEE Integration?

Instead of uploading a local IMDAA archive, you can point a job at a Google Earth Engine collection. NetCDF Studio will authenticate with GEE using your credentials, fetch the requested data, and run the same processing pipeline — correction engines, unit conversion, and CSV export — on the result.

Billing Clarification

⚠️

You are not charged by NetCDF Studio for Google Earth Engine API usage. GEE data retrieval is billed by Google directly to your GEE account (subject to Google's own free tier and quotas). What your NetCDF Studio plan covers is the server-side computation: CPU, memory, and workers used to process the fetched data.

Cost Item	Who Pays
GEE API calls & data retrieval quota	Google bills your GEE account
Server computation (conversion, corrections)	Covered by your NetCDF Studio plan
Output storage	Covered by your plan quota

Setting Up Your GEE Credential

1

Sign in with Google

Link your Google account from Profile → Google Account. This associates your Google identity with your NetCDF Studio account.

2

Authorize Earth Engine

Go to Settings → Credentials and click Connect Earth Engine. A Google OAuth popup will ask for permission to access your Earth Engine projects. Your refresh token is stored encrypted (AES-256-GCM) on the server — it is never returned to the client after saving.

3

Select a GEE Project

Choose the Google Cloud project linked to your Earth Engine account. This project is used for billing and quota tracking on Google's side.

4

Start a GEE Job

When submitting a new request, choose CMIP6 (Earth Engine) as the data source, specify the collection, variables, and date range, then submit. The job runs the same processing pipeline as a local archive job.

Supported Data Sources

Any publicly accessible GEE ImageCollection your account can read
CMIP6 collections available via GEE catalogue
ERA5, MODIS, Landsat, Sentinel — anything your GEE quota allows

💡

ESGF direct-download (the separate ESGF federation) is not currently supported as a GEE source — use the IMDAA upload flow for ESGF datasets instead.

ERA5 Reanalysis (CDS)

Fetch ERA5 reanalysis data from the Copernicus Climate Data Store directly into your processing pipeline.

What Is ERA5?

ERA5 is the fifth generation of ECMWF's atmospheric reanalysis, providing hourly estimates of atmospheric, land, and ocean variables on a 0.25° global grid from 1940 to present. NetCDF Studio can fetch ERA5 data directly from the Copernicus CDS — no file upload required.

Setting Up Your CDS Credential

1

Create a CDS Account

Register at cds.climate.copernicus.eu and accept the ERA5 licence terms. Once registered, you'll receive a Personal Access Token from your CDS profile page.

2

Add Your CDS Token

In the Dashboard, go to Settings → Credentials. Paste your CDS Personal Access Token in the Climate Data Store section. The token is stored encrypted on the server.

3

Submit an ERA5 Request

On the Home page, select ERA5 as the data source. Choose single-level or pressure-level variables, set your date range, time steps, and geographic region, then submit. The server queues the request with the CDS API and begins downloading when the data is ready.

Available Variables

Level Type	Examples
Single Level	2m temperature, 10m wind U/V, total precipitation, surface pressure, soil moisture, radiation fluxes
Pressure Level	Temperature, geopotential, relative humidity, wind U/V at specified pressure levels (e.g., 500 hPa, 850 hPa)

How It Works

Queuing — ERA5 requests are queued with the Copernicus CDS API. Large requests may take minutes to hours depending on CDS server load.
Download — Once the CDS fulfils the request, NetCDF Studio downloads the NetCDF file and converts it to CSV using the same pipeline as a local archive upload.
Post-processing — All standard features apply: correction engines, unit conversion, CSV preview, and file management.

💡

CDS requests for recent dates (last 5 days) may be slower as this data is served from a different tier. For best performance, request data at least a week old.

⚠️

CDS API usage is subject to Copernicus terms and quotas. NetCDF Studio does not charge for CDS data retrieval — the CDS is a free service operated by ECMWF/Copernicus. Your NetCDF Studio plan covers the server-side processing after the data is downloaded.

Frequently Asked Questions

Common questions about using NetCDF Studio.

What file formats can I upload?

NetCDF Studio accepts .zip archives containing NetCDF (.nc) files. For ERA5 and CMIP6, no upload is needed — the server fetches data directly from the Copernicus CDS or Google Earth Engine.

What data sources are supported?

Three sources are available on the Home page: Upload Archive (your own IMDAA ZIP files), ERA5 (Copernicus Climate Data Store), and CMIP6 (NASA NEX-GDDP via Google Earth Engine). Each source feeds into the same CSV processing pipeline.

What is the maximum upload size?

Uploads are capped at 500 MB on the free tier and 2 GB on Pro and Max plans. Enterprise upload limits are negotiated per account. For larger archives, run NetCDF Studio locally — the CLI and Python tools process files of any size on your own computer.

How do I set up ERA5 access?

Register at cds.climate.copernicus.eu, accept the ERA5 licence terms, then paste your CDS Personal Access Token in Settings → Credentials. See the ERA5 Reanalysis page for details.

Does NetCDF Studio charge for external data?

No. ERA5 data from the Copernicus CDS is free. GEE/CMIP6 usage is billed by Google to your GEE account. Your NetCDF Studio plan covers server-side computation only. See the Google Earth Engine page for a full cost breakdown.

Do I need Python installed?

No. The web app handles everything in the cloud. Python is only used on the server side — you never need to install anything locally.

Can I re-use uploaded archives?

Yes. Previously uploaded archives are saved in your workspace. You can select them again during the upload step to create new CSV variants without re-uploading.

How long is my data retained?

Processed files are retained according to your membership plan's data retention policy (shown on the Files page). Job scratch data on Compute Nodes is deleted immediately after each job completes. You can delete files at any time from the Files page to free up storage.

How do I check my storage usage?

Go to the Files page — the storage quota bar at the top shows how much of your plan's storage is used. Your plan and storage limit are also shown on the Profile page under Membership Access.

AWS Open Data

Retrieve atmospheric datasets from the AWS Open Data Registry without leaving NetCDF Studio.

What is AWS Open Data?

The AWS Open Data Registry is a catalogue of publicly available scientific datasets hosted on Amazon S3. NetCDF Studio can fetch selected atmospheric and climate datasets from this registry directly into your processing pipeline — no AWS account or IAM credentials required for the supported open datasets.

Supported Datasets

IMDAA Reanalysis (AWS S3) — The Indian Monsoon Data Assimilation and Analysis dataset is mirrored on AWS Open Data. NetCDF Studio can retrieve specific variables and date ranges directly from S3, bypassing the need for manual downloads.

ERA5 (via CDS) — ERA5 is retrieved through the Copernicus CDS API rather than AWS directly. See the ERA5 Reanalysis page.

How to Use AWS Open Data

On the Dashboard Home page, select the AWS tab from the data source selector.
Choose a dataset from the dropdown (e.g., IMDAA Reanalysis).
Select the variables you need using the chip grid (e.g., Temperature at 2m, Wind Speed).
Set the date range — hourly, 6-hourly, or daily granularity depending on the dataset.
Click Request. The server fetches the relevant S3 objects and queues a conversion job.

No AWS Credentials Required

The datasets available through the AWS tab are part of the AWS Open Data program — they are publicly accessible without authentication. NetCDF Studio handles the S3 access server-side; you never need to configure or supply AWS credentials.

Output

Fetched data goes through the same conversion pipeline as uploaded archives: variable selection, scientific corrections (if enabled), unit conversion, and final CSV export. The resulting files appear on your Files page once the job completes.

ESGF Federation

Access CMIP6 and other climate model outputs via the Earth System Grid Federation.

What is ESGF?

The Earth System Grid Federation (ESGF) is a global network of data nodes that distributes climate model outputs — including CMIP5, CMIP6, CORDEX, and other multi-model ensembles — produced by major modelling centres worldwide.

ESGF in NetCDF Studio

NetCDF Studio provides two routes to CMIP6 data:

GEE/CMIP6 route — retrieves pre-processed CMIP6 outputs via NASA NEX-GDDP through Google Earth Engine (requires a GEE account). Best for downscaled, bias-corrected projections. See the Google Earth Engine page.
ESGF direct route — supply a dataset ID and file URL from an ESGF node to download and convert a specific model output file directly. This does not require a GEE account but does require you to locate the dataset on an ESGF search portal.

How to Use the ESGF Route

Visit an ESGF search portal (e.g. esgf-node.llnl.gov) and find the dataset you need.
Copy the Dataset ID (e.g. CMIP6.ScenarioMIP.MIROC.MIROC6.ssp585.r1i1p1f3.Amon.tas.gn.v20191108).
Copy the direct File URL for the specific .nc file from the ESGF node.
On the Dashboard Home page, select the ESGF tab.
Paste the Dataset ID and File URL into the respective fields.
Click Request. The server downloads the file and queues a conversion job.

Supported Variables

ESGF files can contain any CMIP6-standard variable. After the file is downloaded, NetCDF Studio extracts all variables present and presents them for selection before generating the CSV output. No pre-configuration of variable names is required.

Notes and Limitations

ESGF file servers can be slow or temporarily unavailable. If a download fails, retry after a few minutes.
File sizes can be large; your plan's upload limit does not apply to ESGF downloads (they are server-side), but your storage quota does count the output files.
Some ESGF nodes require OpenID credentials — NetCDF Studio does not manage ESGF authentication; ensure you supply a publicly accessible file URL.

Membership Plans

Understanding storage quotas, processing limits, and plan tiers.

Plan Overview

NetCDF Studio uses a tiered membership model. Every account starts on the FREE tier automatically. Upgrades to paid tiers require an admin-approved membership application.

Loading plan details…

Membership Application

When you first sign up, your account is placed in the NONE (pending) state. Completing the onboarding wizard submits a membership application to the administrators for review. You will be notified when your membership is approved or if additional information is needed.

To upgrade an existing plan, contact an administrator or use the Upgrade Plan option in the membership wizard (accessible from your Profile page).

Storage Quota

Your storage quota covers all files in your workspace — uploaded archives, generated CSV outputs, and correction results. The quota bar on the Files page shows current usage. You can free space at any time by deleting individual files or using Settings → Purge Studio Files to remove all outputs.

Processing Threads

Processing threads control how many conversion jobs can run in parallel for your account. On the FREE tier, only one job runs at a time — additional submissions are queued. PRO and MAX plans support concurrent processing, which significantly reduces turnaround time when working with multiple datasets.

Membership States

NONE — New account; application not yet submitted or still in review.
PENDING — Application submitted and awaiting admin approval.
FREE — Active free-tier membership.
PRO — Active PRO membership.
MAX — Active MAX membership.
ENTERPRISE — Active Enterprise membership (custom quota).
EXPIRED — Membership lapsed; contact an admin to renew.