The exact loss and detection window vary by crop, climate, growth stage and severity of stress, but the underlying opportunity is real: satellite observations can reveal changes in vegetation condition before damage becomes obvious during conventional field inspection.

For developers and data scientists, that creates a valuable engineering problem.

Instead of asking a farmer to inspect hundreds of hectares manually, what if a Python application could automatically collect the latest satellite observation, calculate vegetation health, identify unusual changes and show the affected areas on a web map?

That is exactly what we are going to build.

In this tutorial, you will learn how to use Sentinel-2 Level-2A satellite data with Python, calculate the Normalized Difference Vegetation Index (NDVI) and display the result on an interactive map. The same workflow can later become the foundation of a precision-agriculture platform, crop-insurance application, agricultural lending system, drought-alert service or geospatial analytics API.

At Zam Zam Satellite, satellite imagery and geospatial data are used to turn Earth-observation information into practical intelligence for agriculture, infrastructure, environmental monitoring and other commercial applications. This tutorial demonstrates the technical thinking behind that type of workflow.

Quick Answer: How Can You Monitor Crops with Sentinel-2 and Python?

A basic Sentinel-2 crop-monitoring pipeline has six steps:

1. Define the farm or agricultural area you want to monitor.

2. Search the Copernicus Data Space Ecosystem for recent Sentinel-2 Level-2A imagery.

3. Download a low-cloud satellite scene.

4. Extract Sentinel-2 Band 4 and Band 8.

5. Calculate NDVI using Python and Rasterio.

6. Display the result with Folium or feed the values into an alerting system.

Once automated, the pipeline can run whenever new imagery becomes available.

What Is Sentinel-2?

Sentinel-2 is an Earth-observation mission developed for the European Union's Copernicus programme. Its multispectral sensor observes the Earth's surface in 13 spectral bands, making the mission particularly useful for vegetation, agriculture, forestry, land-use and environmental analysis.

ESA lists a maximum spatial resolution of 10 metres, a 290 km swath and a nominal five-day revisit time for the Sentinel-2 constellation.

That combination is one reason Sentinel-2 is so useful for agriculture.

Why 10-Metre Resolution Matters

At 10-metre resolution, one pixel represents approximately:

10 m × 10 m = 100 m²

For many farms, this is detailed enough to detect meaningful differences between areas of a field rather than treating an entire property as one uniform block.

Sentinel-2's 10-metre bands include:

B02 – Blue

B03 – Green

B04 – Red

B08 – Near Infrared

Band 4 and Band 8 are particularly important because they allow us to calculate NDVI.

Why the Five-Day Revisit Matters

Crop conditions do not stay static.

Water stress, pest damage, disease, irrigation problems and changing weather conditions can alter vegetation rapidly.

Sentinel-2's frequent observations make it possible to build a time series of crop condition rather than relying on a single satellite image. ESA specifically highlights Sentinel-2's frequent revisit and spectral capabilities as useful for monitoring plant health and growth.

There is an important distinction, however.

Is Sentinel-2 Really “Real-Time”?

Strictly speaking, no.

Sentinel-2 should usually be described as near-real-time satellite monitoring rather than continuous real-time observation.

Its nominal revisit is measured in days, and clouds may prevent some optical images from being usable.

For an agricultural application, “real-time monitoring” normally means that your system automatically processes the latest available observation as soon as suitable new data becomes available.

That is what we will design here.

Why Use Sentinel-2 Level-2A for Crop Monitoring?

Sentinel-2 products exist at different processing levels.

For vegetation monitoring, Level-2A is generally the practical choice because it provides atmospherically corrected surface-reflectance information suitable for land analysis.

Copernicus makes Sentinel-2 L2A available through its current Data Space APIs, including catalogue, processing and download interfaces.

A typical Level-2A product contains imagery such as:

B02 – Blue

B03 – Green

B04 – Red

B05 – Vegetation Red Edge

B06 – Vegetation Red Edge

B07 – Vegetation Red Edge

B08 – Near Infrared

B8A – Narrow Near Infrared

B11 – Short-Wave Infrared

B12 – Short-Wave Infrared

SCL – Scene Classification Layer

For our first crop-health model, we only need:

B04 = Red

and

B08 = Near Infrared

Python Tools for Sentinel-2 Crop Monitoring

You will commonly encounter four libraries in Python remote-sensing tutorials:

pip install sentinelsat rasterio geopandas folium

We will also need:

pip install requests numpy pandas matplotlib shapely

So a convenient installation command is:

pip install requests numpy pandas rasterio geopandas folium matplotlib shapely

What Each Library Does

Rasterio reads and writes satellite rasters such as GeoTIFF and JPEG2000 files.

GeoPandas handles farm boundaries, shapefiles, GeoJSON files and other vector geospatial data.

Folium creates interactive Leaflet-based web maps from Python.

NumPy performs fast mathematical operations on satellite pixels.

Requests communicates with the Copernicus API.

What About sentinelsat?

Older tutorials often use sentinelsat to search and download Sentinel imagery.

There is a problem.

The original Copernicus Open Access Hub that sentinelsat primarily relied on has closed. The sentinelsat GitHub repository was archived in October 2025 and warns that the library is not currently functional for downloading from the newer Copernicus Data Space Ecosystem.

So if you are building a new application in 2026, do not base your production architecture on old SciHub tutorials.

For this project, we will use the current Copernicus Data Space Ecosystem OData API.

That keeps the tutorial usable rather than giving you code that fails as soon as you run it.

Step 1: Define the Farm You Want to Monitor

Let's assume we want to analyze an agricultural area in Punjab, Pakistan.

In a real project, you might already have:

farm shapefiles, GeoJSON boundaries, field polygons from GPS surveys, parcels stored in PostGIS, or boundaries supplied by customers.

For this example, we will create a simple polygon.

import geopandas as gpd from shapely.geometry import box

farm = gpd.GeoDataFrame( { "farm_id": ["wheat_field_001"] }, geometry=[ box( 73.05, # West 31.35, # South 73.15, # East 31.45 # North ) ], crs="EPSG:4326" )

print(farm)

If you already have a GeoJSON file, use:

farm = gpd.read_file("farm_boundary.geojson")

farm = farm.to_crs("EPSG:4326")

Convert the polygon into Well-Known Text:

farm_geometry = farm.geometry.union_all()

aoi_wkt = farm_geometry.wkt

print(aoi_wkt)

This geometry will tell the Copernicus catalogue which part of Earth we want to search.

Step 2: Create a Copernicus Data Space Account

Sentinel data itself is open, but authenticated downloads require a Copernicus Data Space Ecosystem account.

The current CDSE OData documentation uses an access token for authorized product downloads.

Store your username and password as environment variables instead of hardcoding them.

Linux or macOS export CDSE_USERNAME="your_username" export CDSE_PASSWORD="your_password" Windows PowerShell \(env:CDSE_USERNAME="your_username" \)env:CDSE_PASSWORD="your_password"

Then authenticate from Python.

import os import requests

username = os.environ["CDSE_USERNAME"] password = os.environ["CDSE_PASSWORD"]

token_url = ( "https://identity.dataspace.copernicus.eu/" "auth/realms/CDSE/protocol/openid-connect/token" )

response = requests.post( token_url, data={ "client_id": "cdse-public", "username": username, "password": password, "grant_type": "password" }, timeout=60 )

response.raise_for_status()

access_token = response.json()["access_token"]

print("Authentication successful")

Do not upload scripts containing your real password to GitHub.

Use environment variables or a secrets-management system.

Step 3: Search for Recent Sentinel-2 L2A Data

Now we can query Sentinel-2 imagery intersecting our farm.

Instead of hardcoding an old satellite date, let's automatically search the previous 30 days.

from datetime import datetime, timedelta, timezone

end_date = datetime.now(timezone.utc)

start_date = end_date - timedelta(days=30)

start_string = start_date.strftime( "%Y-%m-%dT%H:%M:%S.000Z" )

end_string = end_date.strftime( "%Y-%m-%dT%H:%M:%S.000Z" )

Build the OData query.

catalog_url = ( "https://catalogue.dataspace.copernicus.eu/" "odata/v1/Products" )

max_cloud_cover = 20

odata_filter = ( "Collection/Name eq 'SENTINEL-2' and "

"Attributes/OData.CSC.StringAttribute/any("
"att:att/Name eq 'productType' and "
"att/OData.CSC.StringAttribute/Value eq 'S2MSI2A') and "

f"OData.CSC.Intersects("
f"area=geography'SRID=4326;{aoi_wkt}') and "

f"ContentDate/Start gt {start_string} and "
f"ContentDate/Start lt {end_string} and "

"Attributes/OData.CSC.DoubleAttribute/any("
"att:att/Name eq 'cloudCover' and "
f"att/OData.CSC.DoubleAttribute/Value le {max_cloud_cover})"

)

Submit the search:

params = { "\(filter": odata_filter, "\)orderby": "ContentDate/Start desc", "$top": 10 }

response = requests.get( catalog_url, params=params, timeout=60 )

response.raise_for_status()

products = response.json()["value"]

See what we found:

for product in products: print( product["Name"], product["ContentDate"]["Start"] )

The current CDSE OData service supports product searches using collection, acquisition dates and other product attributes.

Select the newest suitable product:

if not products: raise RuntimeError( "No suitable Sentinel-2 L2A imagery found." )

product = products[0]

product_id = product["Id"] product_name = product["Name"]

print("Selected:", product_name)

Step 4: Download the Sentinel-2 L2A Product

Now download the selected product using the access token.

from pathlib import Path

download_folder = Path("sentinel_data")

download_folder.mkdir( parents=True, exist_ok=True )

download_url = ( "https://download.dataspace.copernicus.eu/" f"odata/v1/Products({product_id})/$value" )

headers = { "Authorization": f"Bearer {access_token}" }

output_zip = ( download_folder / f"{product_id}.zip" )

Stream the file instead of loading the whole archive into memory:

with requests.get( download_url, headers=headers, stream=True, timeout=600 ) as response:

response.raise_for_status()

with open(output_zip, "wb") as file:

    for chunk in response.iter_content(
        chunk_size=1024 * 1024
    ):

        if chunk:
            file.write(chunk)

print("Downloaded:", output_zip)

Copernicus documents authenticated product download through the OData product $value endpoint.

Step 5: Extract the Sentinel-2 Product

Sentinel products normally arrive as compressed archives.

Extract the data:

import zipfile

extract_folder = ( download_folder / product_id )

extract_folder.mkdir( exist_ok=True )

with zipfile.ZipFile( output_zip, "r" ) as archive:

archive.extractall(
    extract_folder
)

Locate the .SAFE directory:

safe_products = list( extract_folder.rglob("*.SAFE") )

if not safe_products: raise RuntimeError( "Sentinel SAFE directory not found" )

safe_directory = safe_products[0]

print(safe_directory)

Step 6: Find Sentinel-2 Band 4 and Band 8

NDVI needs two wavelengths.

Band 4

Red visible light.

B04 Band 8

Near-infrared light.

B08

Find the corresponding 10-metre images:

red_files = list( safe_directory.rglob( "*_B04_10m.jp2" ) )

nir_files = list( safe_directory.rglob( "*_B08_10m.jp2" ) )

if not red_files or not nir_files: raise RuntimeError( "Could not locate B04 or B08." )

red_path = red_files[0] nir_path = nir_files[0]

print("Red band:", red_path) print("NIR band:", nir_path)

Both B04 and B08 are available at 10-metre resolution, which makes them particularly convenient for NDVI generation.

Step 7: Calculate NDVI for Crop Health

NDVI means:

Normalized Difference Vegetation Index

Its equation is:

NDVI = (NIR - Red) / (NIR + Red)

Why does this work?

Healthy vegetation absorbs a significant amount of red light for photosynthesis while reflecting strongly in the near-infrared region.

Stressed vegetation generally produces a different spectral response.

Let's calculate it.

import rasterio import numpy as np

with rasterio.open( red_path ) as red_src:

red = red_src.read(
    1
).astype("float32")

profile = red_src.profile.copy()

with rasterio.open( nir_path ) as nir_src:

nir = nir_src.read(
    1
).astype("float32")

Calculate NDVI:

denominator = nir + red

ndvi = np.where( denominator != 0, (nir - red) / denominator, np.nan )

Check the range:

print( "Minimum NDVI:", np.nanmin(ndvi) )

print( "Maximum NDVI:", np.nanmax(ndvi) )

print( "Mean NDVI:", np.nanmean(ndvi) )

NDVI generally ranges from:

-1 to +1

As a rough conceptual guide:

NDVI Typical Interpretation Below 0 Water, cloud, snow or non-vegetated surfaces 0–0.2 Bare soil or sparse vegetation 0.2–0.4 Limited vegetation 0.4–0.6 Moderate vegetation 0.6–1.0 Dense vegetation

Do not use those ranges as universal crop-health thresholds.

A wheat field at one growth stage cannot automatically be compared with cotton, maize or rice using a fixed NDVI cutoff.

The more useful question is often:

How has this field changed compared with its previous observations?

Step 8: Save NDVI as a GeoTIFF

Let's save our result.

ndvi_path = ( download_folder / "crop_ndvi.tif" )

profile.update( driver="GTiff", dtype="float32", count=1, nodata=-9999, compress="deflate" )

ndvi_output = np.where( np.isfinite(ndvi), ndvi, -9999 ).astype("float32")

with rasterio.open( ndvi_path, "w", **profile ) as dst:

dst.write(
    ndvi_output,
    1
)

print( "NDVI raster saved:", ndvi_path )

You now have a georeferenced NDVI raster that can be opened in:

QGIS, ArcGIS, Python, PostGIS, cloud GIS platforms, or your own application.

Step 9: Clip NDVI to the Farm Boundary

Downloading a whole Sentinel tile gives you much more imagery than you need.

Clip the NDVI raster to your actual agricultural polygon.

from rasterio.mask import mask

with rasterio.open( ndvi_path ) as src:

farm_projected = farm.to_crs(
    src.crs
)

shapes = [
    geometry.__geo_interface__
    for geometry
    in farm_projected.geometry
]

clipped_ndvi, transform = mask(
    src,
    shapes,
    crop=True
)

clipped_profile = (
    src.profile.copy()
)

Update its metadata:

clipped_profile.update( height=clipped_ndvi.shape[1], width=clipped_ndvi.shape[2], transform=transform )

Save it:

clipped_path = ( download_folder / "farm_ndvi.tif" )

with rasterio.open( clipped_path, "w", **clipped_profile ) as dst:

dst.write(
    clipped_ndvi
)

Now the output represents your farm rather than the entire satellite tile.

Step 10: Visualize Crop Health on an Interactive Map

Raster values are useful to a data scientist.

A farmer, operations manager or customer may prefer a map.

This is where Folium becomes useful.

First read the clipped NDVI:

import folium import matplotlib.pyplot as plt

from rasterio.warp import ( transform_bounds )

with rasterio.open( clipped_path ) as src:

ndvi_data = src.read(
    1
).astype("float32")

ndvi_data[
    ndvi_data == src.nodata
] = np.nan

west, south, east, north = (
    transform_bounds(
        src.crs,
        "EPSG:4326",
        *src.bounds,
        densify_pts=21
    )
)

Create an NDVI visualization:

normalized = np.clip( (ndvi_data + 0.2) / 1.0, 0, 1 )

rgba = plt.get_cmap( "RdYlGn" )(normalized)

rgba[..., 3] = np.where( np.isfinite(ndvi_data), 0.75, 0 )

Create the map:

center_lat = ( south + north ) / 2

center_lon = ( west + east ) / 2

crop_map = folium.Map( location=[ center_lat, center_lon ], zoom_start=13, tiles="OpenStreetMap" )

Overlay the NDVI:

folium.raster_layers.ImageOverlay( image=rgba, bounds=[ [south, west], [north, east] ], opacity=0.8, name="NDVI" ).add_to(crop_map)

Add the field boundary:

folium.GeoJson( farm.to_json(), name="Farm Boundary" ).add_to(crop_map)

folium.LayerControl().add_to( crop_map )

crop_map.save( "crop_health_map.html" )

Open:

crop_health_map.html

You now have an interactive satellite crop-health map.

One NDVI Image Is Not Crop Monitoring

This is where many beginner tutorials stop.

That is also where the genuinely useful work begins.

A single NDVI layer tells you what vegetation looked like during one acquisition.

A crop-monitoring system compares observations through time.

Suppose your application's database contains this:

Date Mean NDVI 2026-02-01 0.48 2026-02-06 0.55 2026-02-11 0.63 2026-02-16 0.67 2026-02-21 0.52

The important number is not simply:

NDVI = 0.52

The interesting signal is:

Previous: 0.67 Current: 0.52 Change: -0.15

That field may deserve investigation.

You could implement a basic alert:

previous_ndvi = 0.67 current_ndvi = 0.52

change = ( current_ndvi - previous_ndvi )

if change <= -0.10:

print(
    "Crop health anomaly detected."
)

A production system would use a more sophisticated baseline, but the principle remains the same.

Monitor change, not just colour.

Do Not Diagnose Drought from NDVI Alone

A decrease in NDVI does not automatically mean drought.

It could indicate:

irrigation failure, disease, pest damage, cloud contamination, flooding, harvest, crop maturity, bare soil exposure, lodging, replanting, or another field-management event.

Satellite analytics should therefore flag an anomaly, not invent a diagnosis.

A more advanced model could combine:

Sentinel-2 vegetation indices + rainfall + temperature + soil moisture + crop calendar + historical field behaviour

That is considerably more defensible than saying:

NDVI dropped = drought

Don't Forget Cloud Masking

Another common mistake is filtering solely by scene-level cloud percentage.

Imagine a Sentinel scene is only 5% cloudy.

That sounds excellent.

But if that 5% happens to cover your 20-hectare wheat field, the image may still be useless.

Level-2A data includes supporting information such as scene classification that can be incorporated into quality-control workflows. Copernicus notes that Level-2A products include scene-classification information alongside surface-reflectance data.

A production application should therefore perform field-level cloud masking before calculating crop statistics.

Turning This Python Script into a Real Product

The NDVI equation is not the difficult part.

This is:

ndvi = ( nir - red ) / ( nir + red )

Anyone can copy that.

The commercial value lies in building a system around it.

A useful satellite crop-monitoring architecture could look like:

Sentinel-2 ↓ Automatic Data Search ↓ Cloud Filtering ↓ Farm Boundary Extraction ↓ NDVI / NDRE / NDMI ↓ Historical Comparison ↓ Anomaly Detection ↓ Database ↓ API / Dashboard / Alerts

Then your application could return something like:

{ "farm_id": "PK-001", "crop": "wheat", "observation_date": "2026-02-21", "mean_ndvi": 0.52, "previous_ndvi": 0.67, "change": -0.15, "status": "investigate", "valid_pixels": 94.7 }

That is a useful product.

A raw satellite image is not.

Where Sentinel-2 Crop Monitoring Becomes Valuable

This architecture can support much more than a farm map.

Precision Agriculture

Automatically identify sections of a farm that differ from normal crop-development patterns.

Agricultural Insurance

Use historical and current Earth-observation data to support field assessment and claims investigation.

Agricultural Lending

Track crop development across financed farming portfolios.

Food Supply Chains

Monitor agricultural production areas before procurement or harvesting decisions.

AgriTech Startups

Build an API where customers send field boundaries and receive vegetation analytics.

Government Monitoring

Analyze crop patterns across districts, provinces or entire agricultural regions.

Irrigation Management

Compare vegetation response across irrigated fields and identify anomalous zones requiring inspection.

This ability to convert multispectral imagery into GIS-ready decision intelligence is also central to the satellite and geospatial work offered through Zam Zam Satellite. The real value is not simply acquiring imagery; it is turning remote-sensing data into information that businesses and operational teams can act on.

Frequently Asked Questions

Is Sentinel-2 satellite data free?

Yes. Copernicus provides open access to Sentinel data and associated processing services through the Copernicus Data Space Ecosystem.

What is the resolution of Sentinel-2?

Sentinel-2 has spectral bands at 10 m, 20 m and 60 m spatial resolution. Important visible and near-infrared bands including B04 and B08 are available at 10-metre resolution.

How often does Sentinel-2 capture the same location?

The Sentinel-2 constellation has a nominal five-day revisit cycle under the standard two-satellite mission configuration. Actual availability of usable optical imagery may be lower because of clouds and other conditions.

Which Sentinel-2 bands are used for NDVI?

Use:

B08 = Near Infrared B04 = Red

Then calculate:

NDVI = (B08 - B04) / (B08 + B04)

Why use Sentinel-2 Level-2A instead of Level-1C?

Level-2A products provide atmospherically corrected surface reflectance, making them more convenient for vegetation and land-surface analysis.

Can Python automatically download Sentinel-2 imagery?

Yes. The Copernicus Data Space Ecosystem provides APIs for catalogue searches, authentication, downloads and processing that developers can integrate into automated applications.

Does sentinelsat still work?

It should not be the foundation of a new CDSE application. Its repository is archived and states that it is not currently functional for downloads from the Copernicus Data Space Ecosystem.

Is Sentinel-2 suitable for real-time crop monitoring?

It is more accurate to call it near-real-time monitoring. A system can automatically process the latest suitable satellite observation, but Sentinel-2 does not continuously observe a farm.

Final Thoughts

Downloading Sentinel-2 imagery and calculating NDVI takes surprisingly little Python.

Building a useful crop-intelligence system requires more.

The real workflow is:

Acquire → Validate → Process → Compare → Detect → Alert

Start with B04, B08 and NDVI. Then add cloud masking, time-series analysis, NDRE, moisture indices, weather data, field-level statistics and anomaly detection.

At that point, you are no longer building an NDVI demo.

You are building agricultural geospatial intelligence.

For companies that want satellite imagery and geospatial information without building the entire acquisition and processing infrastructure internally, Zam Zam Satellite provides access to satellite-data and geospatial solutions that can be adapted to agricultural monitoring, mapping and other business applications.

The satellite imagery is only the input.

The real product is the decision you can extract from it.