You need accurate, near real-time visibility on LNG carriers to plan loadings, validate ETAs, and keep terminals safe and efficient. By the end of this guide you will be able to search for LNG-capable vessels, stream live tracks (with route and recent port calls), roll up multiple ships into a single fleet request, and pull emissions scoring for ESG reporting—all via a single, consistent REST API.
What makes this API practical for LNG carrier tracking
The vessels-api.com platform exposes 18 REST endpoints that cover vessel search, live AIS tracking, fleet operations, port intelligence, and IMO CII emissions scoring. You authenticate every request with a single X-API-Key header and a single base URL (no OAuth, no per-endpoint auth differences):
- Base URL: https://vessels-api.com/api/V1
- Auth: X-API-Key header only
- Consistent JSON envelope: {status, success, message, data}
- Global AIS coverage with near real-time refresh rates
- 7-day free trial; scales from indie apps to enterprise control towers
For LNG carrier workflows, the most useful endpoints are:
- GET /vessels/search — find LNG-capable ships by type/name/IMO/MMSI
- GET /vessels/track — live position, 24–168h history, active route, predicted ETA, weather
- POST /vessels/fleet — batch positions/routes for dashboards and alerts
- GET /ports/congestion — operational context at load/discharge terminals
- GET /vessels/green — IMO CII emissions scoring for ESG/compliance
Search LNG carriers you actually care about
Start by locating LNG-capable vessels in your portfolio or region using /vessels/search. You can query by vessel name (fuzzy), IMO, MMSI, and filter by type, flag, tonnage, and build year. The response includes essential particulars for selection and filtering.
cURL: find LNG-capable vessels by name substring and flag
curl -H "X-API-Key: YOUR_API_KEY" "https://vessels-api.com/api/V1/vessels/track?mmsi=258785000&hours=48"Key details you will read from the response:
- data.vessels[].imo, data.vessels[].mmsi — choose stable identifiers for downstream calls
- data.vessels[].vessel_type — confirm you’re targeting LNG Tanker
- data.pagination.* — implement paging for large search result sets (max per_page=100)
Live LNG carrier tracking with route, recent ports, and ETAs
Once you have MMSI or IMO, /vessels/track returns a live AIS position, optional history (up to 168 hours), the active route (departure/destination), predicted ETA if available, and recent port calls. For LNG operations this aligns control-room dashboards with planner timelines and berth schedules.
Official cURL sample (copy/paste): track by MMSI with a 48-hour window
Official JSON sample (verbatim):
{
"status": 200,
"success": true,
"message": "OK",
"data": {
"vessel": {
"imo": "9122556",
"mmsi": "258785000",
"name": null
},
"current_position": {
"latitude": 53.33708,
"longitude": 7.17993,
"speed_knots": 0,
"course_degrees": 212,
"heading_degrees": null,
"navigational_status": 5,
"timestamp_utc": "2017-01-24T04:07:57+00:00",
"age_minutes": 5129960,
"destination": null,
"eta": null
},
"predicted_eta": null,
"position_history": [],
"route": {
"departure_port": "HERACLIO",
"departure_time": "2026-04-27T21:35:36+00:00",
"destination_port": "HERACLIO",
"eta": null,
"distance_nm": null,
"avg_speed_knots": 17.1
},
"last_port_visits": [
{
"port_id": "156",
"port_name": "EMDEN",
"arrival_time": "2026-07-30T13:00:10+00:00",
"departure_time": null,
"duration_hours": null
},
{
"port_id": "10",
"port_name": "HERACLIO",
"arrival_time": "2026-04-20T12:00:00+00:00",
"departure_time": "2026-04-23T08:00:00+00:00",
"duration_hours": 68
}
],
"weather": null
}
}How to use these fields in LNG workflows:
- data.current_position.speed_knots, course_degrees — to display real-time movement; knots and degrees relative to true north
- data.current_position.timestamp_utc — timestamps are UTC ISO-8601; display age in minutes to surface stale AIS
- data.route.departure_port, destination_port, avg_speed_knots — show active voyage context in dashboards
- data.last_port_visits[] — confirm LNG-related port calls or terminal cycles
- data.predicted_eta — when present, feed into berth allocation and shore-side logistics
Tip: You can request route and weather explicitly using include_route=true and include_weather=true if you want to guarantee those sections are computed for your call pattern. The hours parameter supports up to 168 for a 7-day window.
JavaScript example: call /vessels/track and normalize essentials
async function fetchLNGTrack() {
const url = "https://vessels-api.com/api/V1/vessels/track?mmsi=258785000&hours=48";
const res = await fetch(url, {
headers: { "X-API-Key": "YOUR_API_KEY" }
});
if (!res.ok) {
throw new Error(`HTTP ${res.status}`);
}
const json = await res.json();
const { status, success, message, data } = json;
if (!success) {
throw new Error(message || "API error");
}
const pos = data.current_position;
const route = data.route || {};
return {
mmsi: data.vessel.mmsi,
imo: data.vessel.imo,
lat: pos.latitude,
lon: pos.longitude,
speedKn: pos.speed_knots,
courseDeg: pos.course_degrees,
navStatus: pos.navigational_status,
tsUtc: pos.timestamp_utc, // UTC ISO-8601
destination: pos.destination || route.destination_port || null,
predictedEta: data.predicted_eta || pos.eta || route.eta || null,
avgSpeedKn: route.avg_speed_knots || null,
lastPorts: data.last_port_visits || []
};
}
fetchLNGTrack()
.then(console.log)
.catch(console.error);Track multiple LNG carriers in one request
LNG planners and chartering desks often monitor multiple hulls simultaneously. Instead of looping single-ship calls, use POST /vessels/fleet to retrieve positions and routes for a list of IMO/MMSI identifiers in one payload. This reduces client-side complexity and tail latency for dashboards.
cURL: batch two LNG carriers and include positions
Read these fields:
- data.fleet.vessels_at_sea, vessels_in_port — high-level operational status
- data.vessels[].position — current lat/lon/speed/time for map pins and alerts
- data.vessels[].route — departure/destination/ETA if available
Implementation notes:
- Send a mixed list of IMO and MMSI; the service resolves either identifier
- Use server-side rate limiting responsibly; if you maintain large lists, consider chunking
- Cache responses for short intervals in your UI (e.g., 15–60 seconds) to avoid redundant requests
Port context for LNG terminals
Terminal readiness depends on congestion and wait-time context. Use GET /ports/congestion to retrieve a congestion snapshot and wait-time statistics for supported ports. You must pass the UNLOCODE in the port_id parameter. For example, ARBUE is Buenos Aires; your LNG terminals will have their own port identifiers.
cURL: congestion snapshot by port UNLOCODE
What to expect in the response:
- data.snapshot.vessels_in_anchorage, vessels_at_berth — near real-time port pressure
- data.statistics.avg_wait_time_hours_last_7d — time-to-berth context for planning
- data.statistics.port_calls_count — activity level over the selected period
Do not invent wait times or counts in your application logic; always surface the values as returned by the API. For specific field shapes, see the response schema and the sibling fixture in the docs for the referenced port.
ESG and compliance: IMO CII for LNG carriers
GET /vessels/green returns IMO CII scoring, which many LNG value-chain participants need for reporting and charters. Ratings follow A (best) through E (worst) based on IMO MEPC.339(76). Supply MMSI or IMO, and optionally period with 24h, 7d, 30d (default), or 1y.
cURL: retrieve 30-day CII metrics by MMSI
Key fields to surface in your ESG UI:
- data.estimated_emissions.co2_tons and co2_per_nm — intensity metrics for period comparisons
- data.cii.score and data.cii.rating — the value your compliance team reports
- data.cii.year and regulation_reference — add transparency to audit trails
Putting it together: LNG operations blueprint
Below is a pragmatic sequence for a port-to-port LNG workflow using the endpoints above. You can implement this pattern in a control tower app, a terminal view, or a planner’s dashboard.
- Search and shortlist LNG carriers:
- GET /vessels/search with ship_type=LNG Tanker, build filters by DWT or year if needed
- Store IMO/MMSI for each shortlisted vessel
- Live tracking per hull:
- GET /vessels/track with hours=24–168 depending on historical breadcrumbs you need
- Display speed_knots, course_degrees, timestamp_utc; warn if age_minutes grows
- Show route.departure_port/destination_port and last_port_visits to verify voyage stage
- Fleet rollup:
- POST /vessels/fleet to map all LNG carriers on one screen with status at-sea/in-port
- Use include_routes to enrich pins with next destination summaries
- Terminal context:
- GET /ports/congestion for destination UNLOCODE; surface anchorage/berth counts
- Read wait time statistics for planning tugs, pilots, and berth windows
- ESG rollup:
- GET /vessels/green to display current CII rating and CO2 intensity per voyage period
- Export scores alongside voyage logs for auditability
Python example: end-to-end LNG carrier tracker
This Python script queries a vessel’s live track and prints a concise status line appropriate for a CLI or logs.
import requests
from datetime import datetime
API_KEY = "YOUR_API_KEY"
BASE = "https://vessels-api.com/api/V1"
def iso_to_dt(s):
return datetime.fromisoformat(s.replace("Z", "+00:00")) if s else None
def track_vessel(mmsi="258785000", hours=48):
url = f"{BASE}/vessels/track?mmsi={mmsi}&hours={hours}"
r = requests.get(url, headers={"X-API-Key": API_KEY}, timeout=20)
r.raise_for_status()
payload = r.json()
if not payload.get("success", False):
raise RuntimeError(payload.get("message", "API error"))
d = payload["data"]
pos = d["current_position"]
route = d.get("route") or {}
predicted = d.get("predicted_eta")
vessel = d["vessel"]
return {
"imo": vessel.get("imo"),
"mmsi": vessel.get("mmsi"),
"lat": pos.get("latitude"),
"lon": pos.get("longitude"),
"speed_kn": pos.get("speed_knots"),
"course_deg": pos.get("course_degrees"),
"nav_status": pos.get("navigational_status"),
"ts_utc": pos.get("timestamp_utc"),
"destination": pos.get("destination") or route.get("destination_port"),
"eta": predicted or pos.get("eta") or route.get("eta"),
"avg_speed_kn": route.get("avg_speed_knots"),
"last_ports": d.get("last_port_visits", [])
}
if __name__ == "__main__":
s = track_vessel()
ts = s["ts_utc"]
print(f"MMSI {s['mmsi']} @ ({s['lat']}, {s['lon']}) {s['speed_kn']} kn, "
f"course {s['course_deg']}°, dest {s['destination']}, ETA {s['eta']}, time {ts}")Practical implementation notes
- Units and coordinates:
- Speeds are knots; distances are nautical miles (nm)
- Course/heading are degrees; 0–359 relative to true north
- Lat/lon use decimal degrees
- Time and staleness:
- All timestamps are UTC in ISO-8601 format
- Use age_minutes when present to detect stale AIS and flag in UI
- Pagination and limits:
- /vessels/search supports page/per_page (max 100); always read data.pagination
- /vessels/nearby has radius_nm caps (default 50, max 200) if you later add geofences
- Error handling:
- HTTP 400/422 for missing/out-of-range parameters; 401 for auth errors; 404 for not found
- Implement retries/backoff where needed; honor 429 rate limit responses
- Caching and polling:
- Live AIS refresh is near real-time; pull intervals of 15–60s work well for control rooms
- Cache per vessel to avoid flashing UI updates across large fleets
- Response envelope:
- Every endpoint returns {status, success, message, data}; check success before reading data
Additional endpoints worth adding later
- GET /vessels/analytics — roll up voyage distance, speeds, port calls over 24h/7d/30d/90d
- GET /vessels/nearby — show surrounding traffic around your LNG carrier within a radius NM
- GET /ports, GET /ports/data — pull port catalogs and live vessel counts for terminal maps
FAQ
Q: Do I need different keys or OAuth for different endpoints?
A: No. Use one X-API-Key header for all endpoints under the same base URL.
Q: What’s the maximum history window for /vessels/track?
A: Up to 168 hours (7 days) via the hours parameter.
Q: Can I mix IMO and MMSI in /vessels/fleet?
A: Yes. Provide either identifier per vessel object; the API resolves both.
Q: Are timestamps in local time or UTC?
A: UTC, in ISO-8601 format. Convert client-side if you need local timezones.
Q: How can I detect stale AIS updates?
A: Use current_position.age_minutes (when present) or calculate from timestamp_utc to highlight stale positions.
Next steps
Start with the track example above and plug it into your LNG dashboard. When you’re ready to scale, switch to the fleet endpoint and layer in port congestion and CII scoring. You can explore parameters and field shapes in the official docs and test calls in your environment.
Your integration should take minutes to get running and will give your team the live AIS, voyage context, and compliance data needed to keep LNG operations predictable and safe.
