You need to track dredgers with AIS precision — where they are, where they’ve been in the last hours, how close they are to your channel, and whether congestion will delay your next window. By the end of this guide, you’ll be able to search for dredgers, stream live tracks with up to 168 hours of history, scan nearby traffic around a work zone, assess port congestion, and monitor multi-vessel operations — all with simple, consistent REST calls.
Why dredger teams choose a single, consistent AIS API
Dredging operations run on tight safety perimeters and fixed tidal windows. To plan well and react fast, you need a single API that covers discovery, tracking, fleet visibility, and port-side constraints without juggling multiple auth modes or schemas. With vessels-api.com you get:
- 18 REST endpoints across vessel search, live tracking, fleet operations, port intelligence, IMO CII emissions, and a premium real-time AIS feed.
- One API key, one base URL — no OAuth or per-endpoint auth differences.
- Consistent JSON envelope and fields across endpoints for predictable parsing.
- Global AIS coverage with near real-time refresh rates.
- A 7-day free trial on all plans that scales from indie tools to enterprise fleets.
Everything runs under the base URL https://vessels-api.com/api/V1 with an X-API-Key header on every request.
Core endpoints for a Dredger Tracking API
For dredger-centric systems, these are the endpoints you’ll wire up first:
- GET /vessels/search — identify and filter dredgers and support units.
- GET /vessels/track — live AIS position, 24–168h history, active route, predicted ETA.
- GET /vessels/nearby — traffic picture around a work zone, with distance in NM.
- POST /vessels/fleet — batch state for your dredger + tugs + survey craft.
- GET /ports/congestion — anchorage/berth load and wait-time stats at target ports.
Search for dredgers and build your watchlist
Use GET /vessels/search to find vessels by name, IMO, or MMSI, with filters to zero in on dredgers and support types. Results paginate and include hull particulars (dimensions can help you assess safe approach to the cut or disposal site).
Example: find dredgers by fuzzy name and flag
curl -H "X-API-Key: YOUR_API_KEY" \
"https://vessels-api.com/api/V1/vessels/search?query=dredger&flag=Netherlands&page=1&per_page=50"
Illustrative JSON shape (values shown are examples):
{
"data": {
"vessels": [
{
"imo": "9123456",
"mmsi": "244123456",
"name": "NORTH SEA DREDGER",
"flag": "Netherlands",
"vessel_type": "Dredger",
"gross_tonnage": 5400,
"deadweight_tonnage": 7200,
"year_built": 2002,
"length_m": 120.5,
"width_m": 20.4
}
],
"pagination": {
"current_page": 1,
"per_page": 50,
"total": 8,
"last_page": 1
}
}
}
Key fields you’ll use:
- vessel_type: Filter to “Dredger” or related workboats you track alongside.
- length_m/width_m: Safety and berth-fit logic in UI.
- pagination: Use per_page (max 100) and page to iterate results.
Live dredger tracking with route and ETA
Once you have the IMO or MMSI, GET /vessels/track streams the current AIS position, N-hour track history (up to 168 hours), the active route, and predicted ETA. This is the backbone for dashboards, mobile supervisor views, and automated safety zone alerts.
cURL: Track a vessel (48-hour history)
curl -H "X-API-Key: YOUR_API_KEY" \
"https://vessels-api.com/api/V1/vessels/track?mmsi=258785000&hours=48&include_route=true&include_predicted_eta=true"
Illustrative JSON response (fields as documented; values are examples):
{
"data": {
"vessel": {
"imo": "9234567",
"mmsi": "258785000",
"name": "CAPE CUTTER"
},
"current_position": {
"latitude": 51.9482,
"longitude": 4.0775,
"speed_knots": 4.2,
"course_degrees": 135,
"heading_degrees": 132,
"navigational_status": "Under way using engine",
"timestamp_utc": "2026-09-30T12:05:30Z",
"destination": "ROTTERDAM",
"eta": "2026-09-30T14:20:00Z"
},
"position_history": [
{
"latitude": 51.9631,
"longitude": 4.0152,
"speed_knots": 3.7,
"course_degrees": 122,
"timestamp_utc": "2026-09-30T11:05:30Z"
}
],
"route": {
"departure_port": "NLRTM",
"departure_time": "2026-09-30T09:10:00Z",
"destination_port": "NLRTM",
"eta": "2026-09-30T14:20:00Z",
"distance_nm": 18.4,
"avg_speed_knots": 4.1
},
"last_port_visits": [
{
"port_id": "NLRTM",
"arrival_time": "2026-09-28T07:45:00Z",
"departure_time": "2026-09-28T12:10:00Z"
}
]
}
}
What matters for dredger ops:
- current_position.timestamp_utc: UTC timestamps simplify cross-timezone boards.
- speed_knots and heading_degrees: Anchor zone breach logic and convoy alignment.
- route.distance_nm and eta: Work window readiness and tug dispatching.
- position_history: Playback last hours to validate declared works and transit.
Python example: render a live dredger card
import requests
from datetime import datetime
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://vessels-api.com/api/V1"
def track_dredger(mmsi: str, hours: int = 24):
url = f"{BASE_URL}/vessels/track"
params = {
"mmsi": mmsi,
"hours": hours,
"include_route": "true",
"include_predicted_eta": "true"
}
headers = {"X-API-Key": API_KEY}
r = requests.get(url, params=params, headers=headers, timeout=15)
r.raise_for_status()
payload = r.json()["data"]
vessel = payload["vessel"]
pos = payload["current_position"]
route = payload.get("route", {})
# Render a concise status line
name = vessel.get("name") or vessel.get("imo") or vessel.get("mmsi")
ts = pos.get("timestamp_utc")
ts_local = ts # keep UTC; convert in UI if needed
status = {
"name": name,
"mmsi": vessel.get("mmsi"),
"lat": pos["latitude"],
"lon": pos["longitude"],
"sog_kn": pos["speed_knots"],
"cog_deg": pos["course_degrees"],
"navigational_status": pos.get("navigational_status"),
"last_update_utc": ts_local,
"destination": pos.get("destination"),
"eta_utc": pos.get("eta"),
"route_distance_nm": route.get("distance_nm"),
"route_avg_speed_knots": route.get("avg_speed_knots")
}
return status
if __name__ == "__main__":
card = track_dredger("258785000", hours=48)
print(card)
Implementation details that save time:
- Units: Positions are WGS84 degrees; speeds are knots; distances are nautical miles; timestamps are UTC ISO-8601.
- History window: hours parameter defaults to 24 and supports up to 168 hours.
- Routes: include_route=true returns the voyage context you’ll show beside the live map.
- Caching: For map tiles and UX responsiveness, cache the last successful payload per MMSI and expire on timestamp_utc or a short TTL (e.g., 1–3 minutes).
Build a traffic picture around your cut or disposal site
Dredging safety hinges on situational awareness. GET /vessels/nearby returns all vessels within a given radius of a latitude/longitude point — perfect for drawing a 0.5–5 NM geofence around your dredger and surfacing contacts by type.
Example: 3 NM safety sweep around the dredge site
curl -H "X-API-Key: YOUR_API_KEY" \
"https://vessels-api.com/api/V1/vessels/nearby?latitude=51.95&longitude=4.07&radius=3&limit=100"
Illustrative JSON (values example-only):
{
"data": {
"center": {"latitude": 51.95, "longitude": 4.07},
"radius_nm": 3,
"total": 7,
"vessels": [
{
"imo": "9234567",
"mmsi": "258785000",
"name": "CAPE CUTTER",
"ship_type": "Dredger",
"position": {
"latitude": 51.9482,
"longitude": 4.0775,
"timestamp_utc": "2026-09-30T12:05:30Z"
},
"distance_nm": 0.3,
"speed_knots": 4.2,
"course_degrees": 135,
"navigational_status": "Under way using engine"
}
]
}
}
Use cases:
- Display the closest five contacts sorted by distance_nm on a supervisor tablet.
- Auto-flag fast-approaching targets (speed_knots > 12) for radio calls.
- Filter ship_type to highlight tugs or survey boats attached to the dredger run.
Coordinate multi-vessel dredging fleets
Dredger spreads often include the main dredger, a barge or two, tugs, and a survey launch. The POST /vessels/fleet endpoint gives you a single request for positions and routes for all units, saving network round-trips and simplifying error handling.
Example: batch fetch your spread
curl -X POST -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"vessels":[{"mmsi":"258785000"},{"imo":"9122556"}],"include_positions":true,"include_routes":true}' \
"https://vessels-api.com/api/V1/vessels/fleet"
Illustrative JSON (shortened to essentials):
{
"data": {
"fleet": {
"total_vessels": 2,
"vessels_at_sea": 2,
"vessels_in_port": 0
},
"vessels": [
{
"imo": "9234567",
"mmsi": "258785000",
"name": "CAPE CUTTER",
"position": {
"latitude": 51.9482,
"longitude": 4.0775,
"speed_knots": 4.2,
"course_degrees": 135,
"timestamp_utc": "2026-09-30T12:05:30Z"
},
"route": {
"departure_port": "NLRTM",
"destination_port": "NLRTM",
"eta": "2026-09-30T14:20:00Z"
}
},
{
"imo": "9122556",
"mmsi": null,
"name": "BARGE 12",
"position": null,
"route": null
}
]
}
}
Tips:
- Use include_positions and include_routes to tailor payload weight for mobile links.
- Nulls for some units are normal (e.g., non-transmitting barges). Merge with manual AIS receivers if needed in your app layer.
- Derive “ready state” from fleet.vessels_at_sea and whether the dredger and tug are moving in coordinated headings.
Account for port-side constraints: congestion and wait times
Disposal runs and bunker calls hinge on berth and anchorage availability. GET /ports/congestion provides a snapshot of vessels in anchorage and at berth, plus wait-time statistics over a period window.
Example: congestion around Rotterdam (7-day window)
curl -H "X-API-Key: YOUR_API_KEY" \
"https://vessels-api.com/api/V1/ports/congestion?port_id=NLRTM&period=7d"
Illustrative JSON (values example-only):
{
"data": {
"port_id": "NLRTM",
"port_name": "Rotterdam",
"period": "7d",
"snapshot": {
"vessels_in_anchorage": 31,
"vessels_at_berth": 102
},
"statistics": {
"avg_wait_time_hours_last_7d": 9.6,
"max_wait_time_hours_last_7d": 28.4,
"avg_berth_time_hours_last_7d": 21.2,
"port_calls_count": 1430
}
}
}
Operational implications:
- High vessels_in_anchorage signals potential delays for disposal trips or crew changes.
- Use avg_wait_time_hours_last_7d to adjust slack in convoy turnarounds.
- For scheduled maintenance moves, prefer low-congestion windows to protect working hours.
Designing a dependable dredger tracking stack
Here is a minimal, end-to-end approach to get from selector UI to a live map and an ops dashboard.
1) Build the vessel selector
- Use GET /vessels/search with query=name fragments and filter ship_type to Dredger when available.
- Store IMO/MMSI and static particulars (length_m, width_m) locally to avoid repeated lookups.
2) Stream position and state
- Poll GET /vessels/track every 60–120 seconds for live dashboards; mobile can back off to 3–5 minutes.
- Use hours=24..168 for forensic playback or regulatory reporting of movement corridors.
3) Safety perimeter
- Call GET /vessels/nearby with radius=1–3 NM around the live dredger position.
- Flag any contact closing range quickly or crossing the work zone bearing.
4) Fleet control
- Batch your spread with POST /vessels/fleet to drive a fleet strip at the bottom of the map.
- Show ETA drift across units to catch misaligned departures in your pre-run checklist.
5) Port-side realism
- Query GET /ports/congestion daily for target ports. Surface avg_wait_time_hours_last_7d in planning.
- Use GET /ports for catalog and GET /ports/data to decorate your map with facility context.
Error handling and reliability
- Auth: Every request requires the X-API-Key header. 401 indicates an invalid or missing key.
- Parameters: 400 for missing/invalid input; 422 for out-of-range (e.g., radius too large).
- Missing targets: 404 when a vessel or port ID is not found. In UI, prompt to refine the search or verify identifiers.
- Rate limiting and resilience: Handle 429 with exponential backoff and jitter; ensure cached last-good data is shown with a subtle “stale” badge until the next refresh succeeds.
- Consistency: Responses follow a consistent JSON envelope, making parsing predictable across endpoints. Focus your logic on the data key for the fields shown above.
Security and operational notes
- Always send the API key using the X-API-Key header over HTTPS.
- Store keys server-side; your frontend should call your backend, not the API directly.
- UTC-first: Timestamps are UTC. Convert to local in the frontend, but keep UTC for logs and alerts.
- Pagination: For search, use per_page up to 100 and loop over page to exhaust results.
Putting it together: a simple dredger ops loop
Below is a compact outline for an ops service. It merges search, tracking, and nearby queries to power your dashboard and alerts with minimal moving parts.
# Pseudocode outline:
# 1) On vessel selection, persist mmsi/imo + static fields.
# 2) Every 90s:
# - track = GET /vessels/track?mmsi=...&hours=24&include_route=true
# - safety = GET /vessels/nearby?latitude=track.current_position.latitude&longitude=...&radius=2
# - If any safety.vessels[i].distance_nm < 0.5 and closing speed > threshold, alert.
# - Render card with name, sog/cog, destination, eta, route.distance_nm.
# 3) Every 6h:
# - fleet = POST /vessels/fleet for all support units.
# - congestion = GET /ports/congestion?port_id=...&period=7d
# - Update plan-of-the-day with avg_wait_time and expected slips.
Where to go next
- Try live requests in your browser or HTTP client using the base URL https://vessels-api.com/api/V1 and the X-API-Key header.
- Explore the full catalog (ports, analytics, ESG/IMO CII) to round out compliance and reporting.
- If you need in-IDE tooling, see the MCP link below.
Helpful links:
Register |
Documentation |
MCP
FAQ
How often should I poll for live dredger positions?
For desktop dashboards, 60–120 seconds is a sensible baseline. Mobile can use 3–5 minutes. Cache the last-good payload and update only when timestamp_utc advances.
Can I get more than 24 hours of track history?
Yes. Use the hours parameter on GET /vessels/track up to a maximum of 168 hours.
How do I filter the nearby view to specific vessel types?
Use the ship_type parameter on GET /vessels/nearby to focus on workboats (e.g., dredger, tug, survey). Combine with limit for performance.
What happens if a barge doesn’t transmit AIS?
Batch requests from POST /vessels/fleet may return null for position/route on non-transmitting assets. Represent them as passive units and reconcile with manual updates or local receivers in your app layer.
Do timestamps include time zones?
All timestamps returned by the API are UTC. Convert in your frontend based on user locale or operation theater needs.
Ready to put a reliable dredger tracking API into production? Get an API key, open the docs, and ship your first integration today. Start here: Register and keep the Documentation and MCP handy as you build.
