NextGIS Toolbox provides 150+ tools for online geodata processing. Most of them can be run directly from a web interface: choose a tool, fill in the parameters, run it, and download the result.
There is another way to use the same tools: programmatically.
For Python users, the NextGIS Toolbox SDK provides a convenient interface for calling Toolbox tools from scripts, handling their outputs, and, most importantly, combining multiple tools into automated processing workflows.
The web interface is ideal for one-off processing tasks. When the same operation needs to be repeated regularly, on a schedule, whenever new data arrives, or as part of a larger data pipeline, manually running tools through a browser quickly becomes a bottleneck.
Typical SDK use cases include:
The SDK also handles much of the plumbing that would otherwise have to be implemented separately: logging, error handling, synchronous and asynchronous execution, file uploads and downloads, task progress tracking, and retries.
Every Toolbox tool can also be called directly over HTTP. Individual tool pages provide parameter descriptions and Python examples, and there are additional requests-based examples on GitHub.
Direct HTTP calls are perfectly suitable when you need to integrate one particular tool into existing software and want to keep dependencies to a minimum.
But when a workflow involves multiple tools, the SDK becomes especially useful. The output of one Toolbox operation can be passed directly to another operation without first downloading the intermediate file locally and uploading it again. This is tool chaining.
Instead of treating each geoprocessing operation as an isolated request, you can combine multiple Toolbox tools into a single processing pipeline.
Let’s look at a practical example.
Suppose we want to assess vegetation conditions within an area of interest using satellite imagery.
The workflow can be reduced to three consecutive operations:
planetary_search searches Microsoft Planetary Computer for Sentinel-2 scenes matching a bounding box, date range, and maximum cloud cover.spectral_indices takes the imagery package produced in the previous step and calculates the Normalized Difference Vegetation Index.raster2tiles converts the resulting raster into an NGRC tileset that can be opened in NextGIS Mobile and used in the field without an internet connection.It can all be handled from one Python script:
from toolbox_sdk import ToolboxClient
toolbox = ToolboxClient()
ToolboxClient.configure_logger()
# Step 1: search for Sentinel-2 imagery
imagery_task = toolbox.tool("planetary_search").submit({
"collection": "sentinel-2-l2a",
"bbox": {"west": -89.57, "south": 42.99, "east": -89.23, "north": 43.17},
"start_date": "2024-10-01",
"end_date": "2024-10-31",
"max_cloud_cover": 30,
"max_items": 1,
"asset_keys": "B08,B04",
})
imagery_result = imagery_task.wait_for_completion(timeout=300, poll_interval=5)
# Step 2: calculate NDVI.
# The result of the previous task is passed directly to the next tool,
# without downloading and uploading the intermediate file.
spectral_task = toolbox.tool("spectral_indices").submit({
"sentinel_zip": imagery_result["result_file"],
"index_type": "NDVI",
"generate_series": False,
})
spectral_result = spectral_task.wait_for_completion(timeout=600, poll_interval=10)
# Step 3: convert the NDVI raster to an NGRC tileset
# that can be opened in NextGIS Mobile.
tiles_result = toolbox.tool("raster2tiles")({
"raster_dataset": spectral_result["result_file"],
"palette": toolbox.upload_file("ndvi_palette.txt"),
"zoom_levels": "8-16",
})
print(tiles_result["result_file"])
The same workflow performed manually through the web interface would involve downloading the satellite imagery, uploading it into another tool, waiting for the NDVI calculation, downloading the result again, and then submitting it to the raster tiling tool. And with the SDK, those operations become one automated pipeline.
The script can then be scheduled to run regularly (for example, once a month) to generate an updated vegetation layer without repeating the workflow manually.
The same approach can be used for vector workflows. For example, the result of a layer intersection operation such as qgis_intersect can be passed directly into another processing tool without saving an intermediate dataset locally.
Toolbox SDK supports both synchronous and asynchronous execution.
For relatively short operations, such as format conversion, generalization, or simple raster calculations, a synchronous call is often sufficient:
result = toolbox.tool("convert")({
"source": toolbox.upload_file("input.geojson"),
"format": "GPKG",
})
The script submits the operation and waits until the result is available.
Long-running processing tasks can instead be submitted asynchronously:
task = toolbox.tool("planetary_search").submit(parameters)
The returned task can then be monitored separately:
result = task.wait_for_completion()
This is particularly useful for operations such as satellite imagery processing or other computationally intensive jobs that may take significantly longer than a simple conversion.
Asynchronous execution also makes it possible to separate different parts of a workflow.
A process can submit a task, store its task identifier, and terminate. Another process can later retrieve the task status and continue the workflow once processing has finished.
This can be useful when integrating Toolbox into task queues, scheduled jobs, backend services, or larger distributed processing systems.
NextGIS Toolbox SDK provides another way to access the geoprocessing capabilities. For occasional processing, opening a tool in the browser is the fastest option, but for repeated operations the SDK makes it possible to turn individual tools into reproducible workflows.
And because intermediate results can be passed directly between Toolbox tools, even fairly complex workflows can remain compact and require surprisingly little Python code.
If you already use NextGIS Toolbox interactively, the SDK is a natural next step when you need to automate that work.