# NOAA Sea Level Rise Screener - Site Inundation Threshold (`malonestar/noaa-slr-inundation-threshold-screener`) Actor

Batch coordinates to the NOAA sea level rise increment at which each site first floods (0-10 ft above MHHW), with confidence class, inundated vs low-lying split, levee-exclusion flag and nearest high-tide-flooding thresholds. Out-of-coverage is reported explicitly, never as a false clear. MCP-ready.

- **URL**: https://apify.com/malonestar/noaa-slr-inundation-threshold-screener.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Real estate, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 1,000 screened sites

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## NOAA Sea Level Rise Screener - Site Inundation Threshold

**At what sea level rise does this property flood?** Give it coordinates; it returns the
NOAA sea-level-rise increment at which each site *first becomes inundated* - plus NOAA's
own confidence class, a separate low-lying flag, a levee-exclusion flag, an explicit
out-of-coverage status, and the nearest high-tide-flooding thresholds.

Built directly on the **NOAA Office for Coastal Management Sea Level Rise viewer**
services (`coast.noaa.gov`). Keyless, no scraping of the viewer UI, one billable row
per site.

***

### Why this actor is not just "did the blue layer cover my point"

Three things about this data will produce a confident wrong answer if you get them
wrong, and all three were measured live before this actor was written.

**1. "Not inundated" and "not modelled" look identical.** Anchorage, Alaska is outside
the NOAA sea-level-rise model entirely. Its inundation tile comes back HTTP 200 with a
fully transparent pixel - **byte-identical** to Beacon Hill in Boston, which *is* inside
the model and genuinely dry through 10 ft. Only the data-extent polygon layer separates
them. This actor queries that layer for every site and reports
`in_slr_coverage` / `out_of_coverage` on every row. It will never call an unmodelled
site clear.

**2. Inundated and low-lying are different findings.** NOAA maps *low-lying areas* -
ground below the modelled water level but hydrologically **disconnected** from the
ocean - separately from connected inundation. They are different answers to different
questions, and they are shipped as separate fields (`first_inundation_ft` and
`first_low_lying_ft`, plus a per-increment class). Watch a site move through all three:
the Charleston City Market is dry to 1.5 ft, **low-lying** from 2 ft, and **inundated**
from 3.5 ft.

**3. Leveed areas are excluded from the model, not found to be safe.** The New Orleans
French Quarter reads *not inundated at every increment from 0 to 10 ft*. That is not a
finding of no risk - NOAA does not model inundation behind the mapped levees. This actor
checks NOAA's Louisiana, Texas and Washington leveed-area polygons and returns
`behind_levee: true`, `levee_system_name: "Orleans Metro Polder"` and the verdict
`not_modelled_behind_levee` rather than a false clear.

***

### Who buys this

| Persona | What they do with it |
|---|---|
| **Coastal real-estate / CRE due diligence** | Screen a portfolio before LOI. `first_inundation_ft` under 3-4 ft on a 30-year hold is a financing and insurance conversation. |
| **Insurers and reinsurers** | Batch-score books of coastal exposure with a nationally consistent federal model, and pair the threshold with the nearest station's minor/moderate/major flood levels. |
| **Infrastructure, ports and energy siting** | Substations, terminals, landfall points and O\&M yards. Screen candidate parcels before survey spend. |
| **Phase I ESA / climate-risk disclosure** | A defensible, citable federal screening line for a physical-risk section, with the model's coverage gaps stated rather than hidden. |
| **AI agents (MCP)** | One tool call, one flat row per coordinate, every uncertainty on the row. |

***

### Example input

```json
{
  "assets": [
    { "lat": 32.7808, "lon": -79.9297, "label": "Charleston City Market, SC" },
    { "lat": 25.7907, "lon": -80.13,   "label": "Miami Beach City Hall, FL" },
    { "lat": 29.9511, "lon": -90.0715, "label": "New Orleans French Quarter, LA" },
    { "lat": 42.3583, "lon": -71.0656, "label": "Beacon Hill, Boston MA" }
  ],
  "stepFt": "1",
  "maxFeet": 10,
  "includeConfidence": true,
  "includeLevees": true,
  "includeHighTideFlooding": true
}
```

Real results from that input (measured live):

| Site | Verdict | First inundated | First low-lying | High-confidence wet |
|---|---|---|---|---|
| Charleston City Market, SC | inundated within range | **4 ft** | 2 ft | 3 ft |
| Miami Beach City Hall, FL | inundated within range | **6 ft** | - | 7 ft |
| Embarcadero, San Francisco CA | **inundated at current MHHW** | **0 ft** | - | 0 ft |
| New Orleans French Quarter, LA | **not modelled behind levee** | - | - | - |
| Beacon Hill, Boston MA | not inundated through 10 ft | - | - | - |
| Anchorage, AK | **out of SLR coverage** | - | - | - |

Set `stepFt: "0.5"` to walk half-foot increments: Miami Beach City Hall sharpens from
6 ft to **5.5 ft**. NOAA publishes its confidence raster for whole feet only, so
half-foot steps carry no confidence column at all (rather than a permanently empty one).

***

### Output fields

One row per asset. Every field is nullable: **`null` means "not checked", never
"checked and negative".**

#### Identity and row health

| Field | Meaning |
|---|---|
| `asset_label` | Your label, echoed back. |
| `asset_lat`, `asset_lon` | The coordinates screened (WGS84). |
| `row_status` | `ok`, `invalid_input` (coordinates missing or out of range), or `error` (no NOAA layer answered). |
| `row_error` | Why the row could not be screened. **Null on a healthy row - that is good news, not a dead column.** |

#### Coverage - read this before you read anything else

| Field | Meaning |
|---|---|
| `slr_coverage_status` | `ok` if NOAA's data-extent layer answered, `unavailable` if it did not. |
| `in_slr_coverage` | True if NOAA has modelled this location. **Null if the layer did not answer.** |
| `out_of_coverage` | True when NOAA has *not* modelled the location. Not a finding that it does not flood. |
| `slr_data_extent_oid` | OBJECTID of the containing data-extent polygon. |

Known gaps: **all of Alaska**, Guam and other Pacific territories are outside the
extent. Hawaii, Puerto Rico, the US Virgin Islands and the CONUS coasts are inside it.

#### The answer

| Field | Meaning |
|---|---|
| `slr_verdict` | `inundated_at_current_mhhw`, `inundated_within_modelled_range`, `not_inundated_through_10ft`, `not_modelled_behind_levee`, `out_of_slr_coverage`, or `indeterminate`. It can never read a clear value while a contributing layer is unavailable. |
| `slr_verdict_explained` | A plain sentence stating exactly what the verdict does and does not assert. |
| `first_inundation_ft` | Lowest increment (ft above current MHHW) at which NOAA shows the site **inundated** - connected to the ocean. |
| `first_wet_ft` | Lowest increment at which the site is inundated **or** low-lying. |
| `first_low_lying_ft` | Lowest increment at which NOAA maps the site as a **low-lying area** (below the water level, hydrologically disconnected). |
| `first_low_confidence_ft` | Lowest whole foot at which NOAA's confidence raster reads "low confidence, wet or dry". |
| `first_high_confidence_wet_ft` | Lowest whole foot at which it reads "high confidence area wet". |
| `inundated_at_max_modelled_increment` | Whether the site is inundated at the **highest requested** increment. Null if that increment was never sampled. |
| `max_increment_modelled_ft` | Highest increment this run asked for. |
| `highest_increment_answered_ft` | Highest increment NOAA actually served. Below `max_increment_modelled_ft` means the top of the range was not checked. |
| `increment_step_ft` | 1 or 0.5. |

#### Honesty accounting

| Field | Meaning |
|---|---|
| `increments_requested` / `increments_ok` / `increments_unavailable` | How many increments were asked for, answered, and missing. |
| `increments_unavailable_list` | Which increments (ft) did not answer. Null when all answered. |
| `inundation_monotonic_ok` | Inundation must be non-decreasing as the water rises. False means NOAA returned a physically impossible sequence for this site. |
| `inundation_monotonic_violations` | Which increments broke it. Null on a healthy row. |
| `confidence_monotonic_ok` / `confidence_monotonic_violations` | The same test on the confidence class. |
| `partial_result` | True when at least one requested increment could not be sampled, so the true threshold may sit inside the gap. |

#### Levee exclusion

| Field | Meaning |
|---|---|
| `levee_status` | `ok`, `partial`, `unavailable`, or `not_requested`. |
| `behind_levee` | True inside a NOAA-mapped leveed area. **Null if a levee layer did not answer - never false on an unchecked site.** |
| `levee_system_name` | e.g. `Orleans Metro Polder`. |
| `levee_source_state` | `LA`, `TX` or `WA` - the three states NOAA publishes leveed areas for. |
| `levee_layers_checked` / `levee_layers_failed` | How many of the three answered, and which did not. |

#### Nearest high tide flooding station

NOAA's 99 high-tide-flooding tide stations, with the water levels at which NOAA declares
minor, moderate and major flooding today.

| Field | Meaning |
|---|---|
| `htf_status` | `ok`, `unavailable`, or `not_requested`. |
| `nearest_htf_station_name` / `nearest_htf_station_id` | Station name and NOAA CO-OPS id. |
| `nearest_htf_station_distance_km` | Distance to it. **A distant station is a weak local reference - read this before relying on the thresholds.** |
| `htf_minor_ft_above_mhhw` / `htf_moderate_ft_above_mhhw` / `htf_major_ft_above_mhhw` | Flood thresholds in feet above mean higher high water. |
| `htf_station_mhhw_ft` | The station's published HTF datum offset. |

#### Per increment

For each increment `F` in the requested set (`ft0`, `ft0_5`, `ft1` ... `ft10`):

| Field | Meaning |
|---|---|
| `ft<F>_status` | `ok`, `unavailable`, `out_of_coverage`, or `not_requested`. **`unavailable` means NOT CHECKED - it is never the same as not inundated.** |
| `ft<F>_inundation` | `inundated`, `low_lying`, or `not_inundated`. Null when not checked. |
| `ft<F>_confidence` | `high_confidence_wet`, `low_confidence`, or `high_confidence_dry`. **Whole feet only** - NOAA publishes no confidence raster for half-foot steps, so those columns do not exist. |
| `ft<F>_depth_symbology_rank_pct` | Position on that increment's depth colour ramp, 0 = shallowest rendered, 100 = deepest. **See the depth note below - this is NOT a depth in feet.** Null unless inundated at that increment. |

#### Provenance

| Field | Meaning |
|---|---|
| `sample_zoom_level` | Cached tile level the pixel was read from (15 - the finest level *both* the inundation and confidence services publish, about 4.78 m/px). |
| `sample_resolution_m` | Ground size of the sampled pixel. |
| `sample_tile_row` / `sample_tile_col` / `sample_pixel_x` / `sample_pixel_y` | Exactly which cached pixel produced the answer, so any row can be re-derived by hand. |
| `drift_gate_status` | `passed`, or `passed_with_unavailable_increments`. |
| `drift_gate_checks` | Every value the live drift gate measured on this run, as JSON. |
| `data_source` | The NOAA service family. |
| `low_lying_definition` | The exact meaning of `low_lying`, restated on every row. |
| `depth_note` | Why there is no numeric depth field. |
| `disclaimer` | NOAA's own statement of what this dataset is and is not. |
| `screened_at_utc` | ISO-8601 run timestamp. |

***

### What this actor deliberately does NOT publish

**A numeric inundation depth in feet.** NOAA serves the depth layer as a *continuous,
per-increment stretched colour ramp* - one tile at Charleston contains 162 distinct
colours, and the stretch is rebuilt for every increment. There is no numeric depth in
these services to read. Rather than reverse-engineer a plausible number, this actor
publishes `ft<F>_depth_symbology_rank_pct`: a **relative position on that increment's
own ramp**, clearly named, with a `depth_note` on every row. If you need modelled depth
in feet, download the NOAA SLR depth rasters directly.

**A verdict when a source did not answer.** If the coverage layer or every increment
fails, the verdict is `indeterminate` and the row says so. If *nothing* could be
screened for *any* asset, the run **fails and bills nothing** rather than emitting one
billable "error" row per site.

***

### Live drift assertions

An offline fixture cannot see a silently degraded upstream, because the fixture was
shaped from the degraded data. So this actor re-measures the source on **every run**,
before a single billable row exists, and fails loudly rather than publishing:

- **Legend vocabulary.** The low-lying colour and all three confidence classes are read
  from NOAA's live `/legend` and compared to the values this build was verified against.
  A re-symbolisation fails the run instead of silently re-meaning every answer.
- **Coverage extent.** Polygon count and total area must stay in band (54 polygons and
  1.4376e12 m2 when verified), `exceededTransferLimit` is read, and a polygon with no
  numeric area is a problem rather than zero area.
- **The whole increment set.** A Charleston Harbor marsh point that NOAA models as
  inundated at *every* increment is sampled at every requested increment. Any increment
  that does not read `inundated` there is marked **unavailable** for the whole run; more
  than two and the run fails.
- **A threshold canary.** Miami Beach City Hall must read dry at 4 ft and inundated at
  8 ft, which proves the increments are still ordered as this build expects.
- **A low-lying canary.** A known disconnected pocket must still read `low_lying` at 6 ft.
- **A negative control.** Beacon Hill, Boston must be *inside* coverage and *dry* at
  10 ft - the geospatial form of catching a query that silently matches nothing.
- **An out-of-coverage control.** Denver must fall outside the extent.
- **Per-site monotonicity.** Inundation must be non-decreasing as the water rises.
- **Projection.** Station coordinates are checked by coordinate *magnitude*, so a Web
  Mercator response is caught instantly.

Every measured value is logged and written to `drift_gate_checks` on every row.

You can prove the failure path yourself: set `simulateOutage` to `tiles`, `coverage`,
`legend`, `levees`, `htf` or `all`. The run FAILS, emits 0 rows and bills nothing.

***

### Use as an MCP tool

Available through `mcp.apify.com`. One call, one flat row per coordinate, no follow-up
lookups needed - coverage, verdict, threshold, confidence, levee status and tide-station
thresholds all arrive together, and every uncertainty is a field rather than a footnote.

### Pricing

**$8 per 1,000 results.** One result = one screened coordinate, whatever the increment
step. A failed run emits nothing and bills nothing. Graduated discounts apply on paid
Apify plans.

### FAQ

**Is 10 ft realistic?** It is the top of NOAA's modelled range and is used as a
stress-test bound, not a forecast. NOAA's 2022 Interagency report projects roughly
0.8-1.2 ft of US average rise by 2050. Sites with `first_inundation_ft` of 1-3 ft are
the ones that matter on a normal hold period.

**Is this a flood zone determination?** No. It is a screening tool for potential
sea-level-rise inundation, and it excludes erosion, subsidence, future construction,
wind-driven tides and storm surge. It is not FEMA flood-zone data and it is not for
navigation, permitting or legal purposes. Pair it with FEMA NFIP claims history and
county risk before drawing conclusions.

**Why is my site dry at 10 ft when it floods today?** Check `behind_levee` first, then
`in_slr_coverage`. If both are clean, the site is genuinely above the modelled water
level - and `nearest_htf_station_*` will tell you what today's nuisance-flooding
thresholds are at the nearest tide gauge.

**How precise is a single point?** The sample is one 4.78 m pixel from NOAA's cached
tiles. NOAA states the data shows the *scale* of potential flooding, not the exact
location. `sample_tile_row`/`sample_pixel_x` and friends let you re-derive any row.

### Related actors

Screen the same coordinates against the rest of the coastal and flood shelf:

- **NFIP Flood Loss Risk Screener** - actual paid FEMA flood claim history nearby.
- **FEMA NRI County Risk Profile** - county and tract expected annual loss by peril.
- **CBRS Coastal Barrier Screener** - whether federal flood insurance is barred outright.
- **FWS Wetlands Proximity Screener** and **NHD Surface Water 404 Screener** - the
  jurisdictional water picture.
- **Site Due Diligence Bundle** - 20 layers for one coordinate in one call.

***

*Data: NOAA Office for Coastal Management, Sea Level Rise viewer services
(`coast.noaa.gov/slr`). A screening-level planning tool. Verify with a site visit.*

# Actor input Schema

## `assets` (type: `array`):

Sites to screen against NOAA's sea level rise inundation model. Each item is an object with numeric lat and lon (WGS84 decimal degrees) and an optional label echoed into the output. One billable result row is produced per asset.

## `stepFt` (type: `string`):

How finely to walk the sea level rise increments. 1 ft samples 0,1,2...10 ft and carries NOAA's confidence class on every step. 0.5 ft samples 0,0.5,1...10 ft for a sharper threshold, but NOAA publishes the confidence raster for whole feet only, so confidence is null on the half-foot steps.

## `maxFeet` (type: `integer`):

Stop screening above this many feet of sea level rise. NOAA models 0 through 10 ft. Lowering it makes runs faster but a site that would first flood above the cut-off is reported as not inundated through the increments actually checked, never through 10 ft.

## `includeConfidence` (type: `boolean`):

Sample NOAA's separate confidence raster at each whole-foot increment. It reports high-confidence wet, low confidence (wet or dry), or high-confidence dry, and reflects uncertainty in the elevation data and the tidal datum conversion. Adds one request per whole foot per asset. Turning it off sets the confidence fields to null (not checked), never to a value.

## `includeLevees` (type: `boolean`):

Check the site against NOAA's leveed-area polygons for Louisiana, Texas and Washington. NOAA does not model sea level rise inundation behind these levees, so a dry reading inside one is an ABSENCE OF MODELLING, not a finding of no risk. Without this check the New Orleans French Quarter reads as never inundated through 10 ft.

## `includeHighTideFlooding` (type: `boolean`):

Attach the nearest of NOAA's 99 high tide flooding tide stations and its minor, moderate and major flood thresholds in feet above mean higher high water. This is what turns a sea level rise increment into a present-day nuisance-flooding frame of reference. Costs one request per run, not per asset.

## `maxAssets` (type: `integer`):

Hard cap on how many assets a single run will screen, so an oversized input cannot produce a surprise bill. Assets beyond the cap are skipped and the run logs a warning.

## `simulateOutage` (type: `string`):

Diagnostic seam that forces a NOAA source to fail so the actor's failure path can be proven on demand instead of only during a real outage. Any value other than none makes the run FAIL loudly and emit nothing, so nothing is billed. Leave this alone for real screening.

## Actor input object example

```json
{
  "assets": [
    {
      "lat": 25.7907,
      "lon": -80.13,
      "label": "Miami Beach City Hall, FL"
    }
  ],
  "stepFt": "1",
  "maxFeet": 10,
  "includeConfidence": true,
  "includeLevees": true,
  "includeHighTideFlooding": true,
  "maxAssets": 200,
  "simulateOutage": "none"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "assets": [
        {
            "lat": 32.7808,
            "lon": -79.9297,
            "label": "Charleston City Market, SC"
        },
        {
            "lat": 25.7907,
            "lon": -80.13,
            "label": "Miami Beach City Hall, FL"
        },
        {
            "lat": 38.9784,
            "lon": -76.4835,
            "label": "Annapolis City Dock, MD"
        },
        {
            "lat": 37.7955,
            "lon": -122.3893,
            "label": "Embarcadero, San Francisco CA"
        },
        {
            "lat": 29.9511,
            "lon": -90.0715,
            "label": "New Orleans French Quarter, LA"
        },
        {
            "lat": 42.3583,
            "lon": -71.0656,
            "label": "Beacon Hill, Boston MA"
        },
        {
            "lat": 61.2181,
            "lon": -149.9003,
            "label": "Anchorage, AK"
        }
    ],
    "stepFt": "1",
    "maxFeet": 10,
    "maxAssets": 200,
    "simulateOutage": "none"
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/noaa-slr-inundation-threshold-screener").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "assets": [
        {
            "lat": 32.7808,
            "lon": -79.9297,
            "label": "Charleston City Market, SC",
        },
        {
            "lat": 25.7907,
            "lon": -80.13,
            "label": "Miami Beach City Hall, FL",
        },
        {
            "lat": 38.9784,
            "lon": -76.4835,
            "label": "Annapolis City Dock, MD",
        },
        {
            "lat": 37.7955,
            "lon": -122.3893,
            "label": "Embarcadero, San Francisco CA",
        },
        {
            "lat": 29.9511,
            "lon": -90.0715,
            "label": "New Orleans French Quarter, LA",
        },
        {
            "lat": 42.3583,
            "lon": -71.0656,
            "label": "Beacon Hill, Boston MA",
        },
        {
            "lat": 61.2181,
            "lon": -149.9003,
            "label": "Anchorage, AK",
        },
    ],
    "stepFt": "1",
    "maxFeet": 10,
    "maxAssets": 200,
    "simulateOutage": "none",
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/noaa-slr-inundation-threshold-screener").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "assets": [
    {
      "lat": 32.7808,
      "lon": -79.9297,
      "label": "Charleston City Market, SC"
    },
    {
      "lat": 25.7907,
      "lon": -80.13,
      "label": "Miami Beach City Hall, FL"
    },
    {
      "lat": 38.9784,
      "lon": -76.4835,
      "label": "Annapolis City Dock, MD"
    },
    {
      "lat": 37.7955,
      "lon": -122.3893,
      "label": "Embarcadero, San Francisco CA"
    },
    {
      "lat": 29.9511,
      "lon": -90.0715,
      "label": "New Orleans French Quarter, LA"
    },
    {
      "lat": 42.3583,
      "lon": -71.0656,
      "label": "Beacon Hill, Boston MA"
    },
    {
      "lat": 61.2181,
      "lon": -149.9003,
      "label": "Anchorage, AK"
    }
  ],
  "stepFt": "1",
  "maxFeet": 10,
  "maxAssets": 200,
  "simulateOutage": "none"
}' |
apify call malonestar/noaa-slr-inundation-threshold-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,malonestar/noaa-slr-inundation-threshold-screener"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/vurhVNlc0Q0XrZJRT/builds/xWkzlb3AiEcjDZ1v7/openapi.json