Skip to content

Getting started with the FastFuels API

You are viewing in-progress documentation for v2. Switch to the stable version for the current production release.

The FastFuels API is a web service that builds 3D wildfire fuel data on demand. You send it a polygon as JSON. It fetches the national datasets, runs the fuel science on its own servers, and returns voxelized trees, surface fuels, and terrain — packaged for QUIC-Fire or FlamMap, or as GeoTIFF, NetCDF, and Zarr files.

The API is a REST service. Requests are HTTPS with JSON bodies and an api-key header, with one URL per resource. Any language with an HTTP client can call it — Python, R, JavaScript, a shell — and there’s nothing FastFuels-specific to install, no national dataset to download, and no geospatial toolchain to set up. The same service runs the web application, so a domain you create here opens in the browser, and one you drew in the browser is readable from your script.

This page creates a domain, the resource every other request is built on.

You need an API key. Mint one in the web application under your account settings. The web-app guide API Keys covers the details. Give it the Write scope — a key with only the Read scope can GET, but it can’t create anything, including the domain below.

Set your key once here and every code block on this page picks it up:

my-api-key

You’ll also want curl, or Python with the FastFuels SDK (pip install fastfuels-sdk) if you’re following the Python examples.

A domain is the patch of ground you’re working over. You give it a polygon. The server selects a projected coordinate system, computes the extent, and returns a resource with an ID. It’s the parent of everything else — trees, terrain, and fuel grids all live inside a domain — so it’s the first thing you make.

POST a GeoJSON FeatureCollection to /domains. The polygon below is about a square kilometer at the Blue Mountain Recreation Area, near Missoula, Montana. Run it as-is. Once it works, you can bring your own coordinates.

Domain
The request polygon at the Blue Mountain Recreation Area, near Missoula, Montana.
POST /domains
curl -X 'POST' \
'https://api.fastfuels.silvxlabs.com/v2/domains' \
-H 'accept: application/json' \
-H 'api-key: my-api-key' \
-H 'Content-Type: application/json' \
-d '{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"properties": {},
"geometry": {
"type": "Polygon",
"coordinates": [
[
[-114.09545796676623, 46.8324794598619],
[-114.11217537297199, 46.8324794598619],
[-114.11217537297199, 46.82496749915157],
[-114.09545796676623, 46.82496749915157],
[-114.09545796676623, 46.8324794598619]
]
]
}
}
],
"name": "Blue Mountain Recreation Area",
"description": "Approximately 1 square kilometer near Missoula, Montana.",
"pad_to_resolution": 2
}'

A 201 means the domain was created, and the body is the finished domain. Creating one is immediate, so there’s nothing to wait for. The response includes two fields used later:

  • crs — you sent longitude/latitude, and the server reprojected it into the appropriate UTM zone (EPSG:32611 for western Montana). Everything you build in this domain lands in that coordinate system.
  • id — server-assigned, and the handle for every later request.

Record the id now. The rest of the docs assume you have it:

your-domain-id

Your domain is a container, and the things you build inside it live at domain-scoped URLs:

/domains/{domain_id}
├─ /features roads, water, uploaded layersets
├─ /inventories trees — from TreeMap, canopy height, or your own list
├─ /pointclouds lidar — from USGS 3DEP, or your own scan
└─ /grids the rasterized & voxelized fuelbed
/exports downloadable files, created from a grid or inventory

Child resources are created with a POST to a method path under their collection, such as /grids/topography/3dep or /features/road, and the response is a 201 with the full resource. Every resource is then read with GET .../{id}, changed with PATCH, and removed with DELETE.

Creating a domain was synchronous — the work happened inside the request. Most of what comes next isn’t. Fetching LANDFIRE, expanding TreeMap plots into individual trees, voxelizing a stand: those are asynchronous. The POST returns right away with "status": "pending", a background worker picks the job up, and you re-GET the resource until its status settles on "completed" or "failed". There’s no separate job object to track — the resource carries its own status, progress, and error.

  1. Build something end to end. The QUIC-Fire tutorial runs the full pipeline — fuels, terrain, moisture, export. It opens by creating this same Blue Mountain domain, so paste in your your-domain-id and pick it up at Step 2.

  2. Solve one specific problem. The How-To Guides are recipes, one task each: pull trees from TreeMap, mask fuels with roads, upload your own GeoTIFF, resample a grid.

  3. Understand why it works this way. The Explanation section starts with Introduction to the FastFuels API — why FastFuels is a hosted service, and how the system is put together.

For the exact fields on every endpoint, the service publishes its own reference at /docs. It’s generated by the running API, so it matches the deployed service.

If you work in Python, the FastFuels SDK (pip install fastfuels-sdk) wraps these same calls: it holds your key, polls async jobs to completion, and pages through data for you. It adds no capability over raw HTTP. It reduces boilerplate. The Python examples throughout these docs use it. The curl examples show the same requests as plain HTTP, so they translate to any language.