Air New Zealand (SIN) Routes API
You need to list, analyze, and monitor Air New Zealand (IATA: NZ) routes that touch Singapore Changi (SIN), and wire that into status pages or internal tools. By the end of this guide, you’ll query FlightLabs for NZ schedules, filter by SIN, interpret the JSON for terminals, gates, and timing, and decide when to add real-time tracking or future-flight lookups for your use case.
Air New Zealand and why SIN routes matter for developers
Air New Zealand (IATA: NZ) is the flag carrier of New Zealand. Its primary hub is Auckland (AKL), operating international services across the Pacific and Asia. If your app or internal system needs reliable coverage of NZ services operating to or from Singapore Changi (SIN), the combination of schedules and real-time endpoints in FlightLabs gives you the fields you need to build route maps, flight status boards, and delay monitors.
We’ll anchor on two FlightLabs capabilities:
- Schedules: discover flights operated by NZ and filter for SIN to build route and timetable views.
- Real-time tracking: augment any SIN-bound NZ flights with live status and positions when they’re operating.
Which FlightLabs endpoints to use for NZ routes that involve SIN
There are four relevant areas you’ll likely combine for NZ + SIN workflows:
| Endpoint area | URL (product docs) | Primary purpose | Key fields you'll use | Typical use with NZ + SIN |
|---|---|---|---|---|
| Flight Schedules | www.goflightlabs.com/flights-schedules | Retrieve scheduled flights by airline | flight_number, departure.airport, departure.scheduled, arrival.airport, arrival.scheduled, airline.iata | List NZ services and filter where departure.airport === SIN or arrival.airport === SIN |
| Real-time Tracking | www.goflightlabs.com/real-time | Live flight status and position | flight.status, departure.actual, arrival.estimated, position.latitude/longitude/altitude/speed | Augment scheduled NZ SIN flights with live state (en-route, delayed, gate info) |
| Future Flights | www.goflightlabs.com/future-flights | Forward-looking flight availability | Fields similar to schedules, focused on forward dates | Forecast NZ route availability touching SIN for planning windows |
| Routes | www.goflightlabs.com/retrieve-routes | Route-level reference | Airline IATA, origin/destination IATA, possible aircraft types | Back your schedule queries with static route coverage for NZ to/from SIN |
For the code below, we’ll use the schedules endpoint to retrieve NZ flights, then filter to SIN. When you need live gates, delays, or diversion handling, pair your result set with a real-time call for the same flights.
Explore the platform and data coverage at www.goflightlabs.com. If you prefer to test interactively, the mission control panel is here: MCP.
Query Air New Zealand schedules and filter to SIN
The schedules API returns structured departures and arrivals by airline. We’ll query by airline IATA (NZ) and pick a type value. If you’re mapping all NZ flights that touch SIN, make two passes (type=departure and type=arrival), then filter on the SIN airport code client-side.
curl: retrieve NZ schedules
Replace YOUR_API_KEY with your key. The example below fetches departures for the airline.
curl -G "https://api.goflightlabs.com/flights-schedules" \
--data-urlencode "api_key=YOUR_API_KEY" \
--data-urlencode "iataCode=NZ" \
--data-urlencode "type=departure"
Notes:
- iataCode is your airline filter (NZ).
- type accepts a category like departure or arrival for the schedule set you want.
- Filter for SIN locally by matching departure.airport or arrival.airport to "SIN".
JavaScript example: list NZ routes involving SIN
This snippet requests NZ departures, then filters to any item where either the departure or arrival airport is SIN. In production, repeat the call for type=arrival and merge results to capture all flights that touch SIN.
async function fetchNzSinSchedules() {
const params = new URLSearchParams({
api_key: "YOUR_API_KEY",
iataCode: "NZ",
type: "departure"
});
const url = `https://api.goflightlabs.com/flights-schedules?${params.toString()}`;
const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const json = await res.json();
// Defensive checks based on the documented response shape
const schedules = json && json.data && Array.isArray(json.data.schedules)
? json.data.schedules
: [];
// Filter for flights that either depart from or arrive to SIN
const sinRelated = schedules.filter(item => {
const dep = item.departure && item.departure.airport;
const arr = item.arrival && item.arrival.airport;
return dep === "SIN" || arr === "SIN";
});
// Map fields needed for a route/timetable view
return sinRelated.map(item => ({
flightNumber: item.flight_number,
airline: item.airline && item.airline.iata,
origin: item.departure && item.departure.airport,
originTerminal: item.departure && item.departure.terminal,
schedDepUtc: item.departure && item.departure.scheduled, // ISO 8601 in UTC
destination: item.arrival && item.arrival.airport,
destinationTerminal: item.arrival && item.arrival.terminal,
schedArrUtc: item.arrival && item.arrival.scheduled,
aircraftType: item.aircraft && item.aircraft.type,
registration: item.aircraft && item.aircraft.registration
}));
}
// Example usage
fetchNzSinSchedules()
.then(list => console.log("NZ flights touching SIN:", list))
.catch(err => console.error(err));
Official sample response: fields you’ll use
Below is an official sample of the schedules response structure. Your NZ + SIN results will appear in the same shape. Use these fields to build your UI and to join with real-time status when needed.
{
"success": true,
"data": {
"schedules": [
{
"flight_number": "UA456",
"departure": {
"airport": "SFO",
"scheduled": "2024-03-20T08:00:00Z",
"terminal": "3"
},
"arrival": {
"airport": "ORD",
"scheduled": "2024-03-20T14:15:00Z",
"terminal": "1"
},
"aircraft": {
"type": "Boeing 787-9",
"registration": "N123UA"
},
"airline": {
"name": "United Airlines",
"iata": "UA"
}
}
]
}
}
Field highlights for your NZ + SIN tooling:
- airline.iata: filter for "NZ" to keep only Air New Zealand entries.
- departure.airport and arrival.airport: match "SIN" for origin or destination.
- departure.scheduled and arrival.scheduled: ISO 8601 UTC timestamps; convert to local time zones for display at SIN or the origin/destination.
- departure.terminal and arrival.terminal: terminal data for signage and wayfinding; if you also call real-time, add gate fields when present.
- aircraft.type and aircraft.registration: enrich route cards with aircraft info.
When to add real-time tracking for NZ flights at SIN
Schedules alone won’t tell you if an NZ flight to or from SIN is delayed, en-route, or diverted. For that, join schedules with real-time status. The official real-time response format includes flight.status plus live departure and arrival timing.
{
"success": true,
"data": {
"flight": {
"iata": "AA123",
"icao": "AAL123",
"number": "123",
"status": "en-route",
"departure": {
"airport": "JFK",
"scheduled": "2024-03-20T10:00:00Z",
"actual": "2024-03-20T10:05:00Z",
"terminal": "8",
"gate": "B12"
},
"arrival": {
"airport": "LAX",
"scheduled": "2024-03-20T13:15:00Z",
"estimated": "2024-03-20T13:20:00Z",
"terminal": "4",
"gate": "45A"
},
"position": {
"latitude": 39.8729,
"longitude": -98.7372,
"altitude": 35000,
"speed": 495,
"heading": 270
}
}
}
}
How to use these fields for NZ + SIN:
- flight.status: check for values like en-route, scheduled, landed, delayed, cancelled, or diverted as your UI logic requires.
- departure.actual vs departure.scheduled: compute departure delay.
- arrival.estimated vs arrival.scheduled: compute arrival delay for live boards at SIN.
- terminal and gate under departure and arrival: display wayfinding details; cache for a few minutes and refresh on polling cadence (see below).
- position: enable a live map for NZ long-haul sectors touching SIN.
You can review API structure and broader capabilities here: Documentation. To get an API key and start sending requests, use Register.
Practical implementation details for NZ + SIN routes
Time zones and UTC
- Schedules and real-time timestamps are provided as ISO 8601 in UTC (e.g., 2024-03-20T08:00:00Z). Convert to local time zones for user-facing displays: Singapore (Asia/Singapore) and New Zealand (e.g., Pacific/Auckland).
- Store raw UTC in your database; render in end-user local time at the edge to avoid repeated conversions and daylight saving issues.
Polling and caching for live tracking
- For SIN-bound or SIN-origin NZ flights that are en-route, poll real-time status at a moderate cadence (e.g., 30–60 seconds) and cache responses for the same duration to control costs and load.
- For scheduled flights not yet in operation, poll less frequently (e.g., 5–10 minutes) until within your “go-live” window, then switch to live cadence.
- Gate and terminal details change less often than position; consider storing those separately with a slightly longer TTL (e.g., 2–5 minutes) unless a change event is detected.
Handling cancelled or diverted flights
- Use flight.status in real-time to detect cancelled or diverted events. For diverted flights, arrival.airport may differ from SIN; update your displays to reflect the new destination and suppress SIN terminal/gate.
- For cancelled flights, keep the schedule row but mark the status prominently and remove live position tracking.
Pagination and volume management for schedules
- When requesting airline schedules (iataCode=NZ), expect multiple pages depending on the service day or query limits. If the API returns paging cursors or limit parameters, follow them to iterate through all items. If not exposed, perform multiple time-sliced calls or process results in batches.
- Filter early: as soon as a batch is parsed, discard entries whose departure.airport and arrival.airport are both not SIN to keep memory use low.
Joining schedules with real-time
- Join on a combination of airline.iata and flight_number. If your application also has date context, match the operating day to avoid collisions.
- If a callsign or ICAO number is present in your real-time result, store it alongside the schedule row for future joins.
Use cases for NZ routes at SIN
1) Flight status pages for NZ at SIN
- Data inputs: schedules for the day (flight_number, departure/arrival.scheduled, terminals) plus real-time (status, actual/estimated, gates).
- Behavior: show upcoming NZ departures from SIN and arrivals to SIN; when flight.status transitions to en-route, display a map using position fields and compute live delay from scheduled vs actual/estimated.
2) Delay monitoring and alerts
- Data inputs: real-time status fields (status, departure.actual, arrival.estimated) combined with scheduled timestamps.
- Behavior: calculate delay deltas and fire alerts for SIN operations when thresholds are exceeded (for example, more than N minutes vs scheduled). Persist historical deltas with timestamps for trend analysis.
3) Route and capacity analysis
- Data inputs: schedules (origin/destination, aircraft.type, registration) across multiple days, optionally combined with future-flights to gauge planned availability.
- Behavior: analyze which NZ city pairs operate through SIN, how aircraft types vary by day, and when service windows cluster. Use this to power travel planning tools and operational staffing at SIN.
Building a minimal NZ + SIN route service: step-by-step
1) Retrieve NZ schedules
Call the schedules endpoint with iataCode=NZ. Store UTC timestamps and parse the array under data.schedules.
2) Filter and normalize for SIN
Keep only items where departure.airport === "SIN" or arrival.airport === "SIN". Normalize fields into your database model: flightNumber, airlineIata, origin, destination, schedDepUtc, schedArrUtc, terminals, aircraftType, registration.
3) Join with real-time for operating flights
When a schedule row is in the operation window (for example, within the same day), fetch real-time details. Use flight.status, gate, and timing fields to update the corresponding schedule entry. If your UI shows a map, render position.latitude/longitude and refresh at your live cadence.
4) Handle exceptions
If status indicates delayed, cancelled, or diverted, adjust the display. For diversions, arrival.airport may not be SIN anymore; update the record and, if necessary, remove it from SIN boards.
5) Cache and rate-manage
Use a layered cache: slower refresh for schedules, faster refresh for live flights. Only poll real-time for NZ flights that are active or within your operation window at SIN.
Airport context for SIN (reference data)
For airport display boards or routing, pairing schedules with airport details helps with time zone handling and display consistency. The official airport response shape below shows the type of reference you can pull. Use timezone to localize schedule timestamps and terminals to validate data you present.
{
"success": true,
"data": {
"airport": {
"iata": "JFK",
"icao": "KJFK",
"name": "John F. Kennedy International Airport",
"location": {
"lat": 40.6413,
"lon": -73.7781,
"city": "New York",
"country": "United States"
},
"timezone": "America\/New_York",
"terminals": [
"1",
"2",
"4",
"5",
"7",
"8"
],
"runways": [
{
"length_ft": 14511,
"width_ft": 150,
"surface": "concrete",
"designator": "13L\/31R"
}
],
"weather": {
"temp_c": 22,
"visibility_km": 10,
"wind": {
"speed_kts": 8,
"direction_deg": 180
}
}
}
}
}
Practical tips:
- Always render times in the viewer’s local zone or the airport’s timezone to reduce confusion—SIN operates on Asia/Singapore with no daylight saving shifts.
- If you store airport reference locally, set a long TTL and refresh on a daily cadence, since airport reference data changes infrequently.
Find platform-wide docs at www.goflightlabs.com and endpoint references at the linked documentation page above.
Balanced comparison: schedules vs real-time vs future flights vs routes for NZ at SIN
- Schedules: best for generating NZ route lists and timetables touching SIN. Lightweight and cacheable. Doesn’t carry live delay or diversion state.
- Real-time: essential for live boards and operations. Has status, actual/estimated times, terminals, and gates, plus optional position. Requires polling and careful caching.
- Future flights: use when you need forward visibility for planning or demand modeling of NZ services involving SIN. Complements schedules by extending the time horizon.
- Routes: a stable backbone list of which NZ city pairs may operate via SIN. Helpful for pre-populating UI filters and validating schedule coverage.
In practice, start with schedules to identify NZ flights touching SIN, then selectively add real-time for those within your operational window. For planning or analytical products, incorporate future flights and routes to round out the picture.
Authentication, pricing, and getting started
- Authentication: calls are authenticated with an API key. Keep your key in a secure store and inject at runtime.
- Pricing: Starter is $24.99/month. A trial is available (7 days or 50 requests), so you can validate NZ + SIN workflows quickly before committing.
- Tools: test and monitor calls via the MCP.
To obtain your API key and begin integrating NZ + SIN schedules and live tracking, visit Register. For endpoint details, consult the Documentation.
FAQ
- How do I isolate only Air New Zealand flights that touch SIN? Query schedules with iataCode=NZ, then filter where departure.airport === "SIN" or arrival.airport === "SIN". Repeat for type=departure and type=arrival if needed and merge results.
- How should I handle time zones? Store UTC timestamps from schedules and real-time. Convert to Asia/Singapore for SIN displays or to the viewer’s local time; keep both UTC and local in your UI model to reduce repeated conversions.
- What fields indicate delays or changes? Use flight.status from real-time and compare departure.actual vs departure.scheduled and arrival.estimated vs arrival.scheduled to compute delays. Terminal and gate fields may also change during operations.
- What polling rate is reasonable for live SIN boards? For flights en-route or within your pre-departure window, a 30–60 second cadence is common with equivalent cache TTLs. For future or not-yet-operating flights, back off to multi-minute intervals.
- Can I plan ahead for NZ operations at SIN? Yes—combine schedules with future-flights to inspect forward availability, and use routes to validate which city pairs NZ operates through SIN over longer horizons.
Ready to build NZ + SIN route maps, live boards, or analytics into your product? Create your key via Register, explore endpoint details in the Documentation, and keep a browser tab open to www.goflightlabs.com while you iterate.