Getting Started

Get your API key

Every Continuuiti Tools account includes a personal API key. To get yours:

1. Create an account at tools.continuuiti.com with your business email.
2. Open Platform API in the sidebar. Your key (sk_live_...) is generated automatically, so copy it from there.
3. Pass it on every request in the X-API-Key header.

You can regenerate the key at any time from the same page. The old key stops working immediately.

Every Continuuiti API request goes to https://api.continuuiti.com/api/v1/ with an X-API-Key header. Below is the simplest possible request — geocoding an address — that you can run in your terminal right now after generating an API key.

curl -X POST https://api.continuuiti.com/api/v1/geocode/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"address": "350 Fifth Avenue, New York, NY"}'

You’ll get a JSON response with the matched coordinates, formatted address, and a structured quality envelope describing how confident the match is:

{
  "id": 1,
  "original_address": "350 Fifth Avenue, New York, NY",
  "formatted_address": "350 5th Ave, New York, NY 10118, USA",
  "latitude": "40.7484405",
  "longitude": "-73.9856644",
  "quality": {"score": 1.0, "status": "PASSED", "issues": [], "match_type": "building"},
  "created_at": "2026-04-27T10:19:05Z"
}

Pick the API you need: Climate Risk, Geocoder, LULC, Biodiversity, Damage Estimation, Flood Depth, or Hazard History. The cross-cutting sections below (Authentication, Batch & Async, Sandbox, Errors, Rate Limits) apply to all seven APIs.

Authentication

Every Continuuiti API request requires an API key passed in the X-API-Key HTTP header. There is no OAuth flow, no Bearer token, and no query-parameter authentication — only the header. Generate your API key from the Continuuiti API dashboard.

Header pattern

Add a single header to every request. The same key authenticates against every endpoint across all seven APIs.

curl https://api.continuuiti.com/api/v1/exports/geocoding/reports/ \
  -H "X-API-Key: YOUR_API_KEY"

import requests

headers = {"X-API-Key": "YOUR_API_KEY"}
response = requests.get(
    "https://api.continuuiti.com/api/v1/exports/geocoding/reports/",
    headers=headers,
)
data = response.json()

const response = await fetch(
  "https://api.continuuiti.com/api/v1/exports/geocoding/reports/",
  { headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await response.json();

Authentication errors

Requests without an API key, or with an invalid or revoked key, return 401 Unauthorized:

HTTP/2 401
Content-Type: application/json

{"error": "Invalid or missing API key"}

Response fields

Responses contain the documented fields plus a few platform extras: report_id and report_url (a deep link to the report in your dashboard), tools_batch_id and batch_url for batches, and credits_remaining after each submission. Results endpoints return 409 while a job is still running.

Batch & Async Pattern

Several APIs process work asynchronously because each location involves multi-second computation. LULC, Climate Risk, and Flood Depth are always asynchronous; the Geocoder (batches over five addresses), Hazard History (batches), and Carbon Project Screening also use this pattern. They share an identical flow: submit → poll → fetch results. Biodiversity screening is bundled into LULC, so it has no separate job.

The flow

1. POST to /{api}/batch/analyze/ with your locations array. Returns 202 Accepted with a batch_id immediately — processing has not started yet.
2. GET /{api}/batch/{batch_id}/ repeatedly to poll progress. Status moves through PROCESSING and ends at COMPLETED, PARTIAL, or FAILED.
3. GET /{api}/batch/{batch_id}/results/?page=1&page_size=100 to fetch paginated results once the batch reaches a terminal state.

Status values

Per-module variations: single-location jobs never report PARTIAL (a partly-successful single job is stored as COMPLETED). LULC batches report RUNNING instead of PROCESSING; Geocoder batches have no PARTIAL.

Automatic retry behavior

Async APIs retry transient failures automatically before marking a job as failed. The status response surfaces this so your polling logic doesn’t see a transient FAILED that becomes COMPLETED on retry.

While a job is being retried, its status field shows PENDING rather than FAILED, so client polling logic can simply continue.

Polling cadence

Poll every 5 to 10 seconds. Faster polling consumes API quota with no benefit; slower polling delays your application’s response to completion. For long-running batches (LULC at 5,000 locations runs 30+ minutes), consider exponential backoff after the first minute.

import requests
import time

API_BASE = "https://api.continuuiti.com/api/v1"
HEADERS = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}

# 1. Submit batch
response = requests.post(
    f"{API_BASE}/climate-risk/batch/analyze/",
    headers=HEADERS,
    json={
        "locations": [
            {"lat": 28.6139, "lon": 77.2090, "label": "Delhi"},
            {"lat": 19.0760, "lon": 72.8777, "label": "Mumbai"},
        ],
        "scenarios": ["ssp245", "ssp585"],
        "horizons": ["baseline", "2050"],
    },
)
batch_id = response.json()["batch_id"]
print(f"Submitted batch: {batch_id}")

# 2. Poll until terminal
while True:
    status_response = requests.get(f"{API_BASE}/climate-risk/batch/{batch_id}/", headers=HEADERS)
    state = status_response.json()
    print(f"Status: {state['status']} | Progress: {state['progress']['percent_complete']}%")
    if state["status"] in ("COMPLETED", "PARTIAL", "FAILED"):
        break
    time.sleep(10)

# 3. Fetch results (paginated)
page = 1
while True:
    results_response = requests.get(
        f"{API_BASE}/climate-risk/batch/{batch_id}/results/",
        headers=HEADERS,
        params={"page": page, "page_size": 100},
    )
    payload = results_response.json()
    for result in payload["results"]:
        print(f"{result['label']}: {result['result']['composite_score']}")
    if page >= payload["total_pages"]:
        break
    page += 1

Retrieving Your Results

Alongside the per-job results endpoints, every module exposes a uniform read-only export API for listing and fetching your stored reports and batches.

List your reports for a module (paginated and filterable).

Fetch one full report with its results.

List your batches for a module.

Fetch one batch and its reports.

{module} is one of lulc, climate-risk, geocoding, damage-curves, flood-depth, or hazard-history. Carbon screening exports use /api/v1/exports/carbon-screening/sites/, /api/v1/exports/carbon-screening/sites/{id}/, and /api/v1/exports/carbon-screening/parcels/{id}/.

Query parameters: status, page, page_size (max 200), created_after, created_before, and ordering.

Sandbox / Dry-Run Mode

Every endpoint that consumes computation supports a sandbox mode that returns deterministic mock data without burning API quota. Use it for integration tests, CI pipelines, frontend development, or any time you need to exercise the API contract without hitting the real compute path. Sandbox mode is the recommended way to validate your integration before going to production.

Sandbox runs are free. No credits are consumed, even at zero balance, and each run is labelled with a Sandbox badge in your dashboard so it never mixes with real results.

How to enable sandbox mode

For POST endpoints, add "dry_run": true to the request body. For GET endpoints (like Hazard History queries), add ?dry_run=true to the query string. The same input always returns the same output, so you can write deterministic snapshot tests against sandbox responses.

curl -X POST https://api.continuuiti.com/api/v1/geocode/batch/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "addresses": [{"address": "350 Fifth Avenue, New York, NY"}],
    "dry_run": true
  }'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/climate-risk/batch/analyze/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "locations": [{"lat": 28.6139, "lon": 77.2090, "label": "Delhi"}],
        "scenarios": ["ssp245"],
        "horizons": ["2050"],
        "dry_run": True,
    },
)
batch = response.json()
# Sandbox responses include [DRY RUN] prefix in metadata
assert "[DRY RUN]" in str(batch.get("metadata", {}))

const response = await fetch(
  "https://api.continuuiti.com/api/v1/hazard-history/floods/query/?lat=29.76&lon=-95.37&dry_run=true",
  { headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await response.json();
console.log(data.metadata); // includes [DRY RUN] prefix

What sandbox returns

Sandbox responses match the production response shape exactly — same fields, same types, same nesting. Only the values are deterministic mocks. Metadata fields include a [DRY RUN] prefix so you cannot accidentally treat sandbox results as real data:

{
  "metadata": {
    "method_version": "[DRY RUN] climate_risk_v1.0",
    "processing_time_sec": 0.05,
    ...
  }
}

Errors & Status Codes

Continuuiti APIs follow standard HTTP status codes. The response body is always JSON; error responses include an error field with a human-readable message.

HTTP status codes

Error response shape

{
  "error": "Invalid request: 'lat' must be between -90 and 90"
}

Rate Limits

The default limits are 60 requests per minute and 500 requests per hour, per account. When you exceed them, the API returns 429 with a Retry-After header indicating how long to wait.

These limits suit typical integration workloads, including batch submissions of up to 5,000 locations per request. Burst patterns and sustained high-volume usage are supported on commercial plans.

For sustained workloads beyond the defaults, custom rate limits, dedicated capacity, or SLA-backed usage agreements, book a demo to discuss your requirements.

Climate Risk API

The Continuuiti Climate Risk API assesses 12 physical climate hazards across SSP2-4.5 and SSP5-8.5 emissions scenarios and four time horizons (baseline, 2030, 2040, 2050) for any geographic coordinate. Returns hazard ratings, composite risk score with confidence, and a top-risks summary aligned with TCFD physical risk disclosure categories.

12 Climate Hazards

Every climate risk assessment evaluates all 12 hazards by default. Pass the optional hazards array to limit a job to specific hazards.

Risk Levels

Each hazard returns a categorical rating on a 5-tier scale, plus a numeric score (1–5) for aggregation. The composite risk score is the weighted aggregate across all 12 hazards.

Scenarios

Climate projections use two Shared Socioeconomic Pathways:

• SSP2-4.5 (moderate emissions): middle-of-the-road pathway, consistent with current policy pledges. Standard central planning assumption for risk assessment and regulatory disclosure.
• SSP5-8.5 (high emissions): fossil-fueled development with limited climate policy. Standard worst-case stress-test scenario for TCFD and IFRS S2 disclosure.

Time Horizons

Four time horizons are available. Each represents a 20-year averaging window centered on the labeled year (e.g., “2050” = 2040–2059 average), capturing the underlying climate trend rather than year-to-year fluctuation.

Endpoints

Submit a single-location climate risk job. Returns 202 Accepted with a job_id immediately; processing runs asynchronously.

Request body

Response (202 Accepted)

{
  "job_id": "climate_a1b2c3d4e5f6",
  "status": "PENDING",
  "message": "Climate risk assessment queued for processing"
}

Errors

Get the status and progress of a climate risk job.

Response (200 OK)

{
  "job_id": "climate_a1b2c3d4e5f6",
  "status": "RUNNING",
  "lat": 28.6139,
  "lon": 77.2090,
  "scenarios": ["ssp245", "ssp585"],
  "horizons": ["baseline", "2050"],
  "progress": {
    "hazards_completed": 7,
    "hazards_total": 12,
    "current_hazard": "severe_storm"
  },
  "created_at": "2026-04-27T10:00:00Z",
  "updated_at": "2026-04-27T10:02:00Z"
}

Status values: PENDING, RUNNING, COMPLETED, FAILED (see cross-cutting status table).

Errors

Get the full results of a completed climate risk assessment. While the job is still running, this returns 409 with a short status preview ({"error": "Job not completed", "status": "RUNNING"}); poll the jobs endpoint until the job is COMPLETED, then fetch results.

Response (200 OK) — truncated for readability

{
  "job_id": "climate_a1b2c3d4e5f6",
  "status": "COMPLETED",
  "input": {
    "lat": 28.6139, "lon": 77.2090,
    "scenarios": ["ssp245", "ssp585"],
    "horizons": ["baseline", "2050"]
  },
  "location_context": {
    "elevation_m": 212.6,
    "distance_to_coast_km": 1150.0,
    "terrain_type": "flat",
    "land_cover": "built_area"
  },
  "composite_score": {
    "ssp245": {
      "baseline": {"score": 1.0, "rating": "Low", "confidence": 0.85},
      "2050": {"score": 1.93, "rating": "Moderate", "confidence": 0.82}
    },
    "ssp585": {
      "baseline": {"score": 1.0, "rating": "Low", "confidence": 0.85},
      "2050": {"score": 2.12, "rating": "Moderate", "confidence": 0.80}
    }
  },
  "hazards": {
    "heat_wave": {
      "metric": "heat_events",
      "metric_unit": "days/year",
      "baseline_value": 12.5,
      "risk_matrix": {
        "ssp245": {"baseline": "Moderate", "2050": "High"},
        "ssp585": {"baseline": "Moderate", "2050": "Severe"}
      },
      "values": {
        "ssp245": {"baseline": 12.5, "2050": 22.3},
        "ssp585": {"baseline": 12.5, "2050": 28.7}
      },
      "context": {"threshold_celsius": 38.5},
      "status": "OK"
    }
    // ... 11 more hazards
  },
  "top_risks": [
    {"hazard": "heat_wave", "scenario": "ssp585", "horizon": "2050", "rating": "Severe"},
    {"hazard": "precipitation_change", "scenario": "ssp585", "horizon": "2050", "rating": "High"},
    {"hazard": "river_flood", "scenario": "ssp585", "horizon": "2050", "rating": "High"}
  ],
  "metadata": {
    "baseline_period": "1980-2010",
    "generated_at": "2026-04-27T10:05:00Z",
    "method_version": "climate_risk_v1.0",
    "processing_time_sec": 180
  },
  "error": null
}

Errors

Submit a batch of up to 5,000 locations for climate risk assessment. Same flow as single-location: 202 Accepted with a batch_id, then poll. See Batch & Async Pattern for the full flow.

Request body

Response (202 Accepted)

{
  "batch_id": "batch_climate_a1b2c3d4",
  "status": "PROCESSING",
  "total_count": 3,
  "dry_run": false,
  "status_url": "/api/v1/climate-risk/batch/batch_climate_a1b2c3d4/",
  "results_url": "/api/v1/climate-risk/batch/batch_climate_a1b2c3d4/results/"
}

Errors

Get batch status and progress. Same shape as the cross-API batch status pattern.

Response (200 OK)

{
  "batch_id": "batch_climate_a1b2c3d4",
  "status": "PROCESSING",
  "progress": {
    "total": 3,
    "completed": 2,
    "failed": 0,
    "partial": 0,
    "running": 1,
    "pending": 0,
    "percent_complete": 66.7
  },
  "dry_run": false,
  "created_at": "2026-04-27T10:00:00Z",
  "started_at": "2026-04-27T10:00:05Z",
  "completed_at": null
}

Get paginated batch results. Each result item carries the original label and the full per-location climate risk payload.

Query parameters

Response Field Reference

The complete reference for every field returned by the climate risk results endpoint.

Code Examples

Submit a single-location climate risk assessment for Delhi under SSP2-4.5 and SSP5-8.5 at 2050:

curl -X POST https://api.continuuiti.com/api/v1/climate-risk/analyze/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "lat": 28.6139,
    "lon": 77.2090,
    "scenarios": ["ssp245", "ssp585"],
    "horizons": ["baseline", "2050"]
  }'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/climate-risk/analyze/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "lat": 28.6139,
        "lon": 77.2090,
        "scenarios": ["ssp245", "ssp585"],
        "horizons": ["baseline", "2050"],
    },
)
job_id = response.json()["job_id"]

const response = await fetch(
  "https://api.continuuiti.com/api/v1/climate-risk/analyze/",
  {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      lat: 28.6139,
      lon: 77.2090,
      scenarios: ["ssp245", "ssp585"],
      horizons: ["baseline", "2050"],
    }),
  }
);
const { job_id } = await response.json();

Worked End-to-End Example

Real integrations stitch APIs together. The example below geocodes an address, submits a climate risk assessment, polls until completion, and prints the top three projected hazards under SSP5-8.5 at 2050. This is the consultant-ICP “first useful run.”

import requests
import time

API_BASE = "https://api.continuuiti.com/api/v1"
HEADERS = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}

# Step 1: Geocode an address to coordinates
address = "350 Fifth Avenue, New York, NY"
geo_response = requests.post(
    f"{API_BASE}/geocode/",
    headers=HEADERS,
    json={"address": address},
)
geo = geo_response.json()
lat, lon = float(geo["latitude"]), float(geo["longitude"])
print(f"Geocoded {address} -> ({lat}, {lon})")

# Step 2: Submit climate risk assessment for SSP5-8.5 at 2050
submit_response = requests.post(
    f"{API_BASE}/climate-risk/analyze/",
    headers=HEADERS,
    json={
        "lat": lat,
        "lon": lon,
        "scenarios": ["ssp585"],
        "horizons": ["baseline", "2050"],
    },
)
job_id = submit_response.json()["job_id"]
print(f"Submitted climate risk job: {job_id}")

# Step 3: Poll until COMPLETED
while True:
    status_response = requests.get(f"{API_BASE}/climate-risk/jobs/{job_id}/", headers=HEADERS)
    state = status_response.json()
    print(f"Status: {state['status']}")
    if state["status"] in ("COMPLETED", "PARTIAL", "FAILED"):
        break
    time.sleep(10)

# Step 4: Fetch results and print top 3 hazards under SSP5-8.5 at 2050
results = requests.get(f"{API_BASE}/climate-risk/results/{job_id}/", headers=HEADERS).json()
top_3 = results["top_risks"][:3]

print(f"\nTop 3 climate hazards for {address} under SSP5-8.5 at 2050:")
for risk in top_3:
    hazard = risk["hazard"]
    rating = risk["rating"]
    value = results["hazards"][hazard]["values"]["ssp585"]["2050"]
    unit = results["hazards"][hazard]["metric_unit"]
    baseline = results["hazards"][hazard]["values"]["ssp585"]["baseline"]
    delta = value - baseline
    print(f"  {hazard}: {rating} ({value:.1f} {unit}, {delta:+.1f} from baseline)")

Geocoder API

The Continuuiti Geocoder API converts text addresses to geographic coordinates with a structured quality envelope on every response. Pre-validation rejects clearly unusable input before consuming a provider call. Batch endpoints accept up to 5,000 addresses per submission and complete in a few minutes; a 10,000-address workload (two submissions) takes about ten minutes.

Quality Envelope

Every geocoding response includes a structured quality object so you can route results by confidence. The match_type tier is the most actionable field for downstream filtering.

Garbage Detection (pre-validation)

Before any provider call, the API runs five quality checks to reject obviously unusable input. Rejected requests return 200 OK (not 400) because validation succeeded — the address was correctly identified as unusable.

Endpoints

Geocode a single address synchronously. Returns 201 Created with coordinates and quality, or 200 OK with a REJECTED quality envelope for garbage input.

Request body: {"address": "string (3–500 chars)"}

{
  "id": 1,
  "original_address": "350 Fifth Avenue, New York, NY",
  "formatted_address": "350 5th Ave, New York, NY 10118, USA",
  "latitude": "40.7484405",
  "longitude": "-73.9856644",
  "quality": {"score": 1.0, "status": "PASSED", "issues": [], "match_type": "building"},
  "created_at": "2026-04-27T10:19:05Z"
}

Errors: 400 invalid request (missing address, <3 or >500 chars), 404 address not found by provider, 503 transient provider error after retries.

Retrieve a specific previously geocoded address by ID through the export API. Returns 404 if not found.

Submit a batch of up to 5,000 addresses for asynchronous geocoding. Same flow as the cross-cutting batch pattern.

Get batch status and progress. Batch status values: PENDING, PROCESSING, COMPLETED, FAILED. Per-address status uses PENDING, SUCCESS, REJECTED, FAILED; REJECTED (garbage input) addresses are counted separately and do not fail the batch.

Get paginated geocoding results. Query params: page (default 1), page_size (default 100, max 500), status (filter by job status).

Response Field Reference

Code Examples

curl -X POST https://api.continuuiti.com/api/v1/geocode/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"address": "350 Fifth Avenue, New York, NY"}'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/geocode/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"address": "350 Fifth Avenue, New York, NY"},
)
data = response.json()
print(data["latitude"], data["longitude"], data["quality"]["match_type"])

const response = await fetch("https://api.continuuiti.com/api/v1/geocode/", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ address: "350 Fifth Avenue, New York, NY" }),
});
const data = await response.json();
console.log(data.latitude, data.longitude, data.quality.match_type);

LULC API

The Continuuiti LULC API analyzes land use and land cover at any location and over any year range from 2016 to the current year. Returns annual satellite composites and land cover classification across 9 classes for areas of interest from 100 m to 10 km. Processing is asynchronous; typical 6-year analysis runs in 5 to 10 minutes.

9 Land Cover Classes

Quality Indicators

Endpoints

Submit a single LULC analysis job. Returns 202 Accepted with a job_id.

Get job status. Status values: PENDING, RUNNING, COMPLETED, FAILED. Progress object reports years_completed / years_total.

Get full results: per-year RGB composites, classified LULC raster URLs, per-year class percentages, and change-summary deltas across the year range.

{
  "job_id": "lulc_a1b2c3d4e5f6",
  "status": "COMPLETED",
  "input": {"lat": 28.6139, "lon": 77.2090, "size_m": 1000, "start_year": 2020, "end_year": 2025},
  "year_status": {"2020": "OK", "2021": "OK", "2022": "LOW_QUALITY", "2023": "OK", "2024": "OK", "2025": "OK"},
  "artifacts": {
    "rgb_frames": {"2020": {"url": "https://storage.example.com/.../2020.webp", "cloud_free_pct": 95.5}},
    "lulc_frames": {"2020": {"url": "https://storage.example.com/.../2020.png"}}
  },
  "stats": {
    "by_year": {
      "2020": {"water_pct": 2.5, "trees_pct": 15.3, "built_pct": 45.2}
    }
  },
  "change_summary": {
    "from_year": 2020, "to_year": 2025,
    "net_change_pp": {"built_pct": 4.3, "trees_pct": -2.1},
    "top_increases": [{"class": "built", "label": "Built Area", "change_pp": 4.3}],
    "top_decreases": [{"class": "trees", "label": "Trees", "change_pp": -2.1}]
  }
}

Submit a batch of up to 5,000 locations. Body fields mirror the single-location request, with an additional locations array (each with {lat, lon, label?}) and an optional dry_run flag.

Get batch status and progress. Same shape as the cross-API batch status pattern.

Get paginated batch results. Each result contains the per-location LULC payload.

Response Field Reference

Code Examples

curl -X POST https://api.continuuiti.com/api/v1/lulc/analyze/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lat": 28.6139, "lon": 77.2090, "size_m": 1000, "start_year": 2020, "end_year": 2025}'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/lulc/analyze/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"lat": 28.6139, "lon": 77.2090, "size_m": 1000,
          "start_year": 2020, "end_year": 2025},
)
job_id = response.json()["job_id"]

const response = await fetch("https://api.continuuiti.com/api/v1/lulc/analyze/", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    lat: 28.6139, lon: 77.2090, size_m: 1000,
    start_year: 2020, end_year: 2025,
  }),
});
const { job_id } = await response.json();

Biodiversity API

Biodiversity screening (Hansen deforestation, WDPA protected areas, RESOLVE ecoregions, EUDR indicators) is bundled into every LULC+ analysis. There is no separate endpoint to call. Submit via POST /api/v1/lulc/analyze/ (or the batch variant) and the biodiversity results are included in the report, retrievable via GET /api/v1/exports/lulc/reports/{id}/ (the biodiversity field) once the analysis completes.

Damage Estimation API

The Continuuiti Damage Estimation API computes flood damage estimates for buildings using two independent depth-damage models — one tuned to US construction practices and one tuned to international (continental) construction. Returns monetary loss estimates based on flood depth, building occupancy type, structural characteristics, and replacement value. Synchronous: sub-millisecond per building, 5,000 buildings in under 5 seconds.

33 Building Occupancy Types

Buildings are classified by occupancy code. Pass the code in the occupancy field of damage estimation requests.

Flood Zone Types

Endpoints

Compute flood damage for a single building. Returns both US and international model results independently in one response. Provide US-model fields (stories_int, basement, flood_zone, replacement_value) and/or international-model fields (country_iso, floor_area_m2); at least one group required. When you provide stories_int, the other US-model fields (basement, flood_zone, and replacement_value) are required with it.

{
  "status": "COMPLETED",
  "input": {"depth_ft": 5.0, "occupancy": "RES1", "stories_int": "2", "basement": false,
            "flood_zone": "riverine", "replacement_value": 350000,
            "country_iso": "USA", "floor_area_m2": 150},
  "hazus": {
    "damage_ratio": 0.20, "contents_ratio": 0.28,
    "structural_loss": 70000.00, "contents_loss": 49000.00,
    "total_loss": 119000.00, "depth_in_structure_ft": 4.0
  },
  "jrc": {
    "damage_ratio": 0.6265, "total_loss_eur": 77901.57,
    "continent": "north_america", "sector": "residential",
    "depth_m": 1.2192, "fallback_used": false
  }
}

Process up to 5,000 buildings in a single request. Body: buildings array (each with the single-estimate fields plus optional label) and optional dry_run.

Response Field Reference

Code Examples

curl -X POST https://api.continuuiti.com/api/v1/damage/estimate/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "depth_ft": 5.0, "occupancy": "RES1",
    "stories_int": "2", "basement": false, "flood_zone": "riverine",
    "replacement_value": 350000,
    "country_iso": "USA", "floor_area_m2": 150
  }'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/damage/estimate/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "depth_ft": 5.0, "occupancy": "RES1",
        "stories_int": "2", "basement": False, "flood_zone": "riverine",
        "replacement_value": 350000,
        "country_iso": "USA", "floor_area_m2": 150,
    },
)
result = response.json()
print(f"US model loss: ${result['hazus']['total_loss']:,.2f}")
print(f"International loss: EUR {result['jrc']['total_loss_eur']:,.2f}")

const response = await fetch("https://api.continuuiti.com/api/v1/damage/estimate/", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    depth_ft: 5.0, occupancy: "RES1",
    stories_int: "2", basement: false, flood_zone: "riverine",
    replacement_value: 350000,
    country_iso: "USA", floor_area_m2: 150,
  }),
});
const result = await response.json();

Flood Depth API

The Continuuiti Flood Depth API computes scenario-adjusted flood depths for any geographic coordinate, covering both riverine (inland river) and coastal flooding across four return periods, two emissions scenarios, and three time horizons. Returns depth in meters with quality flags indicating coverage and projection confidence. Single-location queries return in roughly 2 seconds.

Return Periods

Scenarios & Horizons

Six scenario-horizon combinations available per request: ssp245_2030, ssp245_2050, ssp245_2080, ssp585_2030, ssp585_2050, ssp585_2080. Plus a baseline reference for both riverine and coastal.

Coastal Parameters

7 Quality Flags

Each riverine and coastal scenario result carries a quality flag (priority order). Use these to route results: normal values are usable as-is; other flags signal coverage gaps or modeling artifacts to handle in your pipeline.

Endpoints

Submit a single flood depth analysis. Returns 202 Accepted with a job_id (or 200 OK directly if dry_run: true).

Get job status. Status values: PENDING, PROCESSING, COMPLETED, FAILED.

Get full results: riverine and coastal depth tables across all scenario-horizon combinations.

{
  "job_id": "fd_abc123def456",
  "status": "COMPLETED",
  "input": {"lat": 38.63, "lon": -90.18, "label": "St. Louis property"},
  "riverine": {
    "baseline": {
      "RP10":  {"depth_m": 8.147},
      "RP100": {"depth_m": 10.148}
    },
    "scenarios": {
      "ssp245_2050": {
        "RP10":  {"projected_depth_m": 8.482, "ratio": 1.041, "flag": "normal"},
        "RP100": {"projected_depth_m": 10.563, "ratio": 1.041, "flag": "normal"}
      },
      "ssp585_2080": {
        "RP100": {"projected_depth_m": 11.402, "ratio": 1.123, "flag": "normal"}
      }
    }
  },
  "coastal": {
    "baseline": {"RP100": {"depth_m": 0.0}},
    "scenarios": {
      "ssp585_2080": {"RP100": {"depth_m": null, "flag": "no_flood"}}
    }
  },
  "metadata": {
    "method_version": "flood_depth_v1.0",
    "processing_time_sec": 2.1,
    "coastal_projection": 50,
    "coastal_subsidence": "wtsub"
  }
}

Batch up to 5,000 locations. Body: locations array (each with {lat, lon, label?}) plus optional coastal_projection, coastal_subsidence, dry_run applied to all.

Batch status (standard pattern).

Paginated batch results.

Response Field Reference

Code Examples

curl -X POST https://api.continuuiti.com/api/v1/flood-depth/analyze/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lat": 38.63, "lon": -90.18, "label": "St. Louis", "coastal_projection": 95}'

import requests

response = requests.post(
    "https://api.continuuiti.com/api/v1/flood-depth/analyze/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"lat": 38.63, "lon": -90.18, "label": "St. Louis", "coastal_projection": 95},
)
job_id = response.json()["job_id"]

const response = await fetch("https://api.continuuiti.com/api/v1/flood-depth/analyze/", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ lat: 38.63, lon: -90.18, label: "St. Louis", coastal_projection: 95 }),
});
const { job_id } = await response.json();

Hazard History API

The Continuuiti Hazard History API queries historical flood and landslide events at any location. Flood queries return clustered episodes with monthly seasonality and precipitation thresholds; landslide queries return individual events with year trend and fatality aggregation. Single-location queries are synchronous (HTTP 201) and return in 1 to 3 seconds; batch endpoints are asynchronous and accept up to 1,000 locations each.

Flood Stats Fields

Landslide Stats Fields

Endpoints

Query flood history at a single location. Returns clustered episodes, monthly seasonality, precipitation thresholds matched to episode dates, and individual events.

{
  "query": {"lat": 29.76, "lon": -95.37, "radius_km": 10.0},
  "stats": {
    "episodes": 172, "reports": 678, "recurrence_months": 1.5,
    "mean_duration_days": 2.8, "peak_month": 5,
    "largest_event_km2": 1863.6, "largest_event_date": "2005-09-24"
  },
  "month_counts": {"1":12,"2":12,"3":13,"4":15,"5":23,"6":16,"7":13,"8":18,"9":21,"10":14,"11":7,"12":8},
  "flood_thresholds": {
    "matched_episodes": 172,
    "peak_daily_mm": {"p25": 11.3, "p50": 25.1, "p75": 44.5},
    "max_3day_mm":   {"p25": 19.2, "p50": 38.7, "p75": 74.2},
    "precip_7day_mm":{"p25": 14.9, "p50": 31.2, "p75": 57.0}
  },
  "events": [
    {"lat": 29.7597, "lon": -95.368, "area_km2": 0.02,
     "start_date": "2017-08-27", "end_date": "2017-08-30",
     "duration_days": 3, "distance_km": 0.2, "year": 2017}
  ]
}

Batch flood history query for up to 1,000 locations. Returns 202 Accepted with a batch_id; retrieve results from the export endpoints once processing completes (typically a few minutes). Each location costs one credit, and the stored report bundles both flood and landslide history.

Query landslide history at a single location. Returns events, year trend, and fatality aggregation. Search radius is fixed at 25 km for now (not yet an adjustable request parameter).

{
  "query": {"lat": 19.08, "lon": 72.88, "radius_km": 25.0},
  "stats": {
    "total_events": 13, "avg_per_year": 1.4, "years_with_events": 6,
    "most_active_year": 2010, "most_active_year_count": 6,
    "trend": "decreasing", "total_fatalities": 24
  },
  "year_counts": {"2007": 1, "2008": 0, "2009": 1, "2010": 6},
  "events": [
    {"lat": 19.069, "lon": 72.8703, "date": "2010-06-25",
     "trigger": "downpour", "category": "landslide", "size": "medium",
     "fatalities": 0, "distance_km": 1.6, "year": 2010}
  ]
}

Batch landslide history query for up to 1,000 locations. Same body shape as the flood batch with default radius_km = 25, and the same asynchronous behavior: a 202 Accepted with a batch_id, then results from the export endpoints. One credit per location, and the stored report bundles both hazards.

Response Field Reference

Code Examples

curl "https://api.continuuiti.com/api/v1/hazard-history/floods/query/?lat=29.76&lon=-95.37&radius_km=10" \
  -H "X-API-Key: YOUR_API_KEY"

import requests

response = requests.get(
    "https://api.continuuiti.com/api/v1/hazard-history/floods/query/",
    headers={"X-API-Key": "YOUR_API_KEY"},
    params={"lat": 29.76, "lon": -95.37, "radius_km": 10},
)
data = response.json()
print(f"Episodes: {data['stats']['episodes']}, Peak month: {data['stats']['peak_month']}")

const url = new URL("https://api.continuuiti.com/api/v1/hazard-history/floods/query/");
url.searchParams.set("lat", "29.76");
url.searchParams.set("lon", "-95.37");
url.searchParams.set("radius_km", "10");

const response = await fetch(url, { headers: { "X-API-Key": "YOUR_API_KEY" } });
const data = await response.json();

Carbon Project Screening API

Carbon Project Screening checks the land parcels in a carbon project for deforestation history and climate risk, so you can gauge project integrity before relying on it. Submit each parcel as a polygon and the API screens all of them over the lookback period you choose. Processing is asynchronous; results are retrieved through the export API.

Endpoints

Submit a carbon project for screening. Returns 202 Accepted with the screening record and the IDs of the two analyses it starts (deforestation and climate). Costs one credit per parcel.

Response (202 Accepted)

{
  "site_id": "site_a1b2c3d4",
  "status": "PENDING",
  "carbon_batch_id": "carbon_e5f6g7h8",
  "climate_batch_id": "climate_i9j0k1l2",
  "climate_submitted": true,
  "redirect_url": "/carbon-screening/site_a1b2c3d4/"
}

Field notes: site_id is the screening record; carbon_batch_id and climate_batch_id are the two analyses it starts; climate_submitted tells you whether the climate run began; redirect_url links to the screening in your dashboard.

Retrieve results through the export API: GET /api/v1/exports/carbon-screening/sites/, .../sites/{id}/, and .../parcels/{id}/.

Code Examples

curl -X POST https://api.continuuiti.com/api/v1/carbon-project-screening/screen/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Example REDD+ Project",
    "project_start_year": 2026,
    "lookback_years": 10,
    "is_dry_run": false,
    "parcels": [
      {"polygon": {"type": "Polygon", "coordinates": [[[112.9,-3.1],[113.0,-3.1],[113.0,-3.0],[112.9,-3.0],[112.9,-3.1]]]}, "label": "Block A"}
    ]
  }'

Frequently Asked Questions

What is the Continuuiti API base URL?

The Continuuiti API base URL is https://api.continuuiti.com/api/v1/. All endpoints across the seven APIs (Geocoder, LULC, Climate Risk, Damage Estimation, Flood Depth, Hazard History, Carbon Screening) are reached by appending the endpoint path to this base URL. For example, climate risk assessment for a single location uses POST https://api.continuuiti.com/api/v1/climate-risk/analyze/.

How do I get a Continuuiti API key?

Sign up for an account at tools.continuuiti.com/accounts/api-docs/ and generate an API key from your dashboard. Every request requires the key in the X-API-Key header. Keys are scoped per account; rate limits apply per key. There is no separate developer plan: every signup gets API access immediately.

Is there an API sandbox or free testing mode?

Yes. Every endpoint that supports dry_run accepts a dry_run query parameter (GET) or body field (POST). Sandbox responses return deterministic mock data — same input always returns the same output — so you can integrate, write tests, and run CI without consuming API quota. Sandbox responses include a [DRY RUN] prefix in metadata so you cannot accidentally treat them as real. See the Sandbox section for details.

What is the difference between sync and async Continuuiti APIs?

Synchronous APIs (Geocoder, Damage Estimation, Hazard History) return results in a single request-response cycle in seconds or sub-seconds. Asynchronous APIs (LULC, Climate Risk, Flood Depth, Carbon Project Screening) require a job-poll-fetch pattern: POST submits the job and returns a 202 with a job_id, GET polls status, GET fetches results when status is COMPLETED. All async APIs share the same flow, status values, and batch pattern. See the Batch & Async section.

What are the Continuuiti API rate limits?

Rate limits apply per API key. Default limits are 60 requests per minute and 500 requests per hour per account; exceeding them returns 429 with a Retry-After header. Batch endpoints accept up to 5,000 locations per submission. For sustained high-volume workloads or custom limits, book a demo to discuss your requirements.

How long do batch jobs take?

Batch processing time depends on the API and batch size. Geocoding completes 10,000 addresses in approximately ten minutes. Climate Risk batches run 2 to 4 minutes per location with controlled concurrency (max 20 parallel jobs). LULC batches run 4 to 6 minutes per location. Flood Depth runs about 2 seconds per location. Damage Estimation is sub-millisecond per building.

What happens if a Continuuiti batch partially fails?

When some locations in a batch fail and others succeed, the batch reaches PARTIAL status (not FAILED). The progress object reports counts for completed, failed, and retrying jobs separately. Failed locations can be retried at no additional credit cost. Use the results endpoint with ?status=FAILED to filter just the failed items for retry.

Are Continuuiti APIs aligned with TCFD or IFRS S2 reporting?

Continuuiti APIs provide screening-level data aligned with TCFD physical risk disclosure categories and IFRS S2 implementation guidance. The Climate Risk API outputs map directly to TCFD’s physical risk taxonomy (acute and chronic hazards, multiple scenarios, multiple time horizons). For full regulatory disclosure preparation, see /methodology/climate-risk/ and consult your compliance team.