# NOAA Tide Predictions Scraper (`automation-lab/noaa-tide-predictions`) Actor

Export official NOAA high and low tide predictions by station and date range, with water level, datum, units, timezone, station identity, and source links.

- **URL**: https://apify.com/automation-lab/noaa-tide-predictions.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Travel, Education, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.72 / 1,000 tide-prediction extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NOAA Tide Predictions Scraper

Export official **NOAA tide predictions** as structured high and low tide events for one or more coastal stations.

Provide NOAA CO-OPS station IDs and a date range. The Actor returns predicted water level, event time, datum, units, station identity, coordinates, timezone context, and direct source URLs. No NOAA API key, browser, proxy, or account is required.

### What does NOAA Tide Predictions Scraper do?

The Actor calls the official NOAA Center for Operational Oceanographic Products and Services (CO-OPS) Data API and Metadata API.

It turns NOAA responses into one consistent dataset row per predicted high or low tide.

Use it to:

- build local tide charts;
- prepare boating or fishing schedules;
- supply tide events to coastal planning tools;
- compare upcoming events across stations;
- refresh spreadsheets and databases on a schedule;
- feed charting, alerting, and marine operations pipelines.

This Actor returns predictions, not observed water levels or marine weather forecasts.

### Who is it for?

**Marine operators** can prepare bounded station schedules for port, marina, or field work.

**Anglers and boating publishers** can create local high/low tide tables without parsing web pages.

**Travel and coastal application developers** can consume normalized JSON from Apify datasets and APIs.

**Analysts and researchers** can compare predicted levels across dates, datums, and stations.

**Automation teams** can schedule recurring runs and deliver results to webhooks, cloud storage, or data warehouses.

### Why use this Actor?

- Official NOAA CO-OPS data and provenance links
- No NOAA API key or login
- Up to 20 station IDs per run
- Inclusive date ranges from 1 to 31 days
- English (feet) or metric (meters) levels
- Seven common vertical datum choices
- GMT, local standard time, or daylight-aware local time
- Explicit limits and validation instead of silently changing input
- Typed dataset output ready for JSON, CSV, Excel, and integrations
- Bounded transient retries for NOAA 429, 5xx, and transport failures

### Input

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `stationIds` | string array | Yes | `8534720` | One to 20 seven-digit NOAA CO-OPS station IDs. |
| `startDate` | string | Yes | — | First date in `YYYY-MM-DD` format. |
| `endDate` | string | Yes | — | Last date in `YYYY-MM-DD` format, inclusive. |
| `datum` | string | No | `MLLW` | Vertical datum: MLLW, MLW, MTL, MSL, MHW, MHHW, or NAVD. |
| `units` | string | No | `english` | `english` for feet or `metric` for meters. |
| `timeZone` | string | No | `lst_ldt` | `gmt`, `lst`, or `lst_ldt`. |
| `maxItems` | integer | No | `20` | Maximum saved events across all stations, from 1 to 5,000. |

Find station IDs in NOAA's public Tides & Currents station map or station pages.

Not every datum is available at every station. NOAA returns a clear error when a selected station/datum combination is unsupported.

### Quick start

1. Open the Actor input page.
2. Enter one or more NOAA station IDs.
3. Choose a start and end date no more than 31 days apart.
4. Keep `MLLW`, feet, and local daylight-aware time, or select alternatives.
5. Set `maxItems` if you need a strict output cap.
6. Click **Start**.
7. Open the **Tide predictions** dataset view.
8. Export JSON, CSV, Excel, XML, or RSS, or use the dataset API.

Example input for Atlantic City, New Jersey:

```json
{
  "stationIds": ["8534720"],
  "startDate": "2026-09-17",
  "endDate": "2026-09-18",
  "datum": "MLLW",
  "units": "english",
  "timeZone": "lst_ldt",
  "maxItems": 20
}
```

### Output fields

| Field | Meaning |
| --- | --- |
| `stationId` | NOAA seven-digit station ID. |
| `stationName` | Official NOAA station name. |
| `state` | State or territory code reported by NOAA. |
| `latitude`, `longitude` | Station coordinates in decimal degrees. |
| `eventType` | `high` or `low`. |
| `timestamp` | Event time in the selected NOAA timezone convention. |
| `predictedWaterLevel` | Predicted level relative to the selected datum. |
| `datum` | Vertical reference used for the level. |
| `units` | `feet` or `meters`. |
| `timeZone` | Requested mode: `gmt`, `lst`, or `lst_ldt`. |
| `stationTimeZoneCode` | Station timezone abbreviation from NOAA metadata. |
| `stationTimeZoneOffsetHours` | Station standard-time UTC offset. |
| `predictionSourceUrl` | Exact official NOAA Data API request. |
| `stationSourceUrl` | Official NOAA station metadata request. |
| `retrievedAt` | UTC retrieval timestamp. |

Fields can be null when NOAA omits optional station metadata. Tide event values are validated before they are saved.

### Output example

```json
{
  "stationId": "8534720",
  "stationName": "Atlantic City",
  "state": "NJ",
  "latitude": 39.356667,
  "longitude": -74.41805,
  "eventType": "high",
  "timestamp": "2026-09-17 00:03",
  "predictedWaterLevel": 3.55,
  "datum": "MLLW",
  "units": "feet",
  "timeZone": "lst_ldt",
  "stationTimeZoneCode": "EST",
  "stationTimeZoneOffsetHours": -5,
  "predictionSourceUrl": "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter?...",
  "stationSourceUrl": "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations/8534720.json?expand=details",
  "retrievedAt": "2026-09-16T12:00:00.000Z"
}
```

### Timestamp choices

Choose `gmt` when downstream systems need one shared UTC convention across stations.

Choose `lst` for fixed local standard time without daylight-saving adjustment.

Choose `lst_ldt` for the local clock convention normally shown to people at the station, including daylight time when NOAA applies it.

The `timestamp` is intentionally preserved in NOAA's `YYYY-MM-DD HH:mm` representation. The row also records the requested mode and station timezone metadata so consumers do not have to guess its meaning.

### Datum and unit choices

`MLLW` is NOAA's common charting and tide-table reference and is the default.

Other supported requests are `MLW`, `MTL`, `MSL`, `MHW`, `MHHW`, and `NAVD`.

Datum availability varies by station. Do not compare numeric levels from different datums as if they shared one reference plane.

English output uses feet. Metric output uses meters.

### How much does it cost to export NOAA tide predictions?

Pricing is pay per event:

- **Actor start:** $0.00005 per run.
- **Tide prediction:** tiered by your Apify plan; BRONZE is $0.0012 per saved high or low event.

Estimate a run as one start event plus one tide-prediction event for every saved high or low tide. For example, 8 saved events incur one start charge and 8 item charges; 100 saved events incur one start charge and 100 item charges.

Your active Apify tier may differ. Platform usage, taxes, refunds, fraud adjustments, disputes, and corrections may affect final billing.

The Actor does not charge a tide-prediction event for rejected, duplicate, empty, or failed source rows.

### Scheduling recurring tide exports

Create a Task with station IDs and a rolling future date window appropriate for your workflow.

Add an Apify schedule to run daily or weekly.

Connect the dataset to a webhook, Make, Zapier, Google Sheets, Amazon S3, or your own ingestion endpoint.

For change detection, compare stable station, timestamp, datum, and units fields between runs. Predictions may be revised by NOAA, so keep `retrievedAt` when auditing refreshes.

The Actor does not itself send alerts or maintain history across runs.

### Multi-station workflow

Pass several station IDs in one run to create a consolidated dataset.

Use `timeZone: "gmt"` when sorting stations across time zones.

Use `maxItems` to cap the complete run. The Actor processes stations in input order and stops once the cap is reached.

For very large programs, split stations into multiple Tasks so each run remains easy to monitor and retry.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~noaa-tide-predictions/runs?token=$APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "stationIds": ["8534720"],
    "startDate": "2026-09-17",
    "endDate": "2026-09-18",
    "datum": "MLLW",
    "units": "english",
    "timeZone": "lst_ldt"
  }'
```

Fetch dataset items using the `defaultDatasetId` returned by the run.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/noaa-tide-predictions').call({
  stationIds: ['9414290'],
  startDate: '2026-10-01',
  endDate: '2026-10-03',
  units: 'metric',
  timeZone: 'lst_ldt'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/noaa-tide-predictions').call(run_input={
    'stationIds': ['8518750', '8443970'],
    'startDate': '2026-09-17',
    'endDate': '2026-09-18',
    'timeZone': 'gmt',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/noaa-tide-predictions"
```

Claude Desktop, Cursor, and VS Code use the equivalent MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/noaa-tide-predictions"
    }
  }
}
```

Example prompts:

- "Export NOAA high and low tide predictions for station 8534720 for September 17–18, 2026."
- "Get San Francisco station 9414290 tide events in meters for the first three days of October."
- "Create a GMT-normalized dataset for NOAA stations 8534720, 8518750, and 8443970."

Always inspect station, date, datum, units, and timezone in generated tool input before running it.

### Limits and failure behavior

- The inclusive date range is limited to 31 days.
- Each run accepts 1–20 station IDs.
- `maxItems` is limited to 5,000.
- Only NOAA high/low prediction events are returned.
- Invalid station IDs fail clearly instead of producing misleading empty rows.
- Unsupported station/datum combinations return the NOAA API error.
- Transient 429, 5xx, and network failures receive up to three bounded attempts.
- Persistent upstream failures make the Actor fail with a non-zero status.
- NOAA may revise predictions or metadata after a run.
- Naturally empty NOAA responses produce no rows for that station.

### Tips for reliable results

Confirm station IDs on NOAA before creating a long-lived Task.

Keep the default `MLLW` unless your workflow requires another datum.

Use `gmt` for cross-time-zone joins and local modes for human-facing schedules.

Store `predictionSourceUrl` with exported data for provenance and reproducibility.

Use small date windows for frequent refreshes rather than repeatedly requesting the 31-day maximum.

### Troubleshooting

#### Why did the run reject my date range?

Dates must be real calendar dates in `YYYY-MM-DD` format, and the inclusive range cannot exceed 31 days. The end date cannot precede the start date.

#### Why did NOAA reject my datum?

Not every station supports every vertical datum. Retry with `MLLW`, or check that station's NOAA datum information.

#### Why are timestamps not ISO strings with offsets?

The NOAA prediction endpoint returns a local or GMT date/time string without an offset suffix. The Actor preserves it and adds explicit timezone mode and station timezone fields rather than inventing an offset.

#### Why are fewer than `maxItems` returned?

`maxItems` is only a ceiling. The number of natural high and low tide events depends on station and date range.

#### Do I need a proxy?

No. The Actor uses NOAA's official public JSON APIs directly.

### Legality and responsible use

Data comes from public US government NOAA CO-OPS services. Review NOAA's notices and terms for your application.

Tide predictions are informational and are not a substitute for official navigation products, local notices, weather warnings, or professional safety judgment.

Do not imply that NOAA endorses this Actor. NOAA names and station metadata identify the public data source; the icon and product are independently operated by Automation Lab.

The Actor sends only the requested station IDs, dates, datum, units, timezone, and standard HTTP metadata to NOAA. It does not use AI, retain a separate customer database, or transmit input to advertising systems.

### Related Automation Lab Actors

- [NOAA Historical Weather Observations](https://apify.com/automation-lab/noaa-historical-weather-observations) — historical atmospheric observations by station and date.
- [Weather.gov Active Alerts Tracker](https://apify.com/automation-lab/us-active-weather-alerts-tracker) — active official US weather warnings and geometries.
- [NOAA Essential Fish Habitat Consultation Screener](https://apify.com/automation-lab/noaa-essential-fish-habitat-consultation-screener) — regulatory habitat screening for supplied project areas.

Choose this Actor when you need predicted tidal high/low events. Choose the related products for weather history, active warnings, or habitat screening.

### FAQ

#### Is a NOAA API key required?

No. Both official endpoints used by this Actor are public and keyless.

#### Can I search by city name or coordinates?

No. This release intentionally accepts authoritative station IDs so selection is deterministic. Resolve the correct NOAA station before running.

#### Does it return hourly predictions?

No. It returns only high and low events (`interval=hilo`), matching the tide-schedule workflow.

#### Does it return observed water levels?

No. Predictions and observations are different products. This Actor does not claim observed or real-time levels.

#### Can I export CSV or Excel?

Yes. Use the dataset export controls or API after the run.

#### Can I schedule it?

Yes. Save the input as an Apify Task, attach a schedule, and connect the resulting dataset to your destination.

#### Is the data safe for navigation?

Treat it as planning data. Consult official charts, notices, forecasts, and local authorities for safety-critical decisions.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/noaa-tide-predictions/changelog.md

# Actor input Schema

## `stationIds` (type: `array`):

One to 20 seven-digit NOAA CO-OPS tide prediction station IDs.

## `startDate` (type: `string`):

First prediction date in YYYY-MM-DD format.

## `endDate` (type: `string`):

Last prediction date in YYYY-MM-DD format. The inclusive range may contain up to 31 days.

## `datum` (type: `string`):

NOAA vertical datum used for predicted water levels. NOAA may not support every datum at every station.

## `units` (type: `string`):

Return predicted levels in feet (English) or meters (metric).

## `timeZone` (type: `string`):

NOAA timestamp convention: GMT, local standard time, or local time with daylight saving.

## `maxItems` (type: `integer`):

Maximum number of high/low events saved across all stations.

## Actor input object example

```json
{
  "stationIds": [
    "8534720"
  ],
  "startDate": "2026-09-17",
  "endDate": "2026-09-18",
  "datum": "MLLW",
  "units": "english",
  "timeZone": "lst_ldt",
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

All predicted high and low tide events from this run.

# 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 = {
    "stationIds": [
        "8534720"
    ],
    "startDate": "2026-09-17",
    "endDate": "2026-09-18"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/noaa-tide-predictions").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 = {
    "stationIds": ["8534720"],
    "startDate": "2026-09-17",
    "endDate": "2026-09-18",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/noaa-tide-predictions").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 '{
  "stationIds": [
    "8534720"
  ],
  "startDate": "2026-09-17",
  "endDate": "2026-09-18"
}' |
apify call automation-lab/noaa-tide-predictions --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/noaa-tide-predictions"
        }
    }
}
```

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/qONFZtdAB7KV6yX20/builds/tqjdU3YzMDbbzAd6q/openapi.json