Fiji Airways (CDG) Flights API

You need to surface reliable Fiji Airways (FJ) operations at Paris Charles de Gaulle (CDG) in your app: arrivals and departures, real-time updates, and forward-looking schedules. This guide shows how to fetch and work with FlightLabs data for Fiji Airways using a simple REST call, parse the results, and build CDG-focused features like status boards, delay alerts, and route coverage views.

Fiji Airways at a glance

Fiji Airways (IATA: FJ) is the flag carrier of Fiji. The airline is based in Fiji, and its primary hub is Nadi International Airport (NAN). If you support Fiji Airways operations at CDG, you’ll typically combine forward schedules with live status and positions to power user-facing and operational tools.

Which FlightLabs endpoints to use for Fiji Airways at CDG

The core data sources you’ll use are:

• Flight Schedules for planning and upcoming operations. Path on the API host: /flights-schedules?iataCode=&type=
• Real-time Flight Tracking for per-flight status and positions (documented on the product site)
• Flight History for analysis or to reconcile completed operations (documented on the product site)
• Routes for carrier network references (documented on the product site)

You can browse the full reference in the Documentation and manage keys, requests, and models in MCP. To start building, create your key at Register.

How the schedule endpoint returns Fiji Airways data

Schedules are great for listing all planned Fiji Airways flights and then filtering to CDG. The scheduling API on the FlightLabs host is surfaced as:

GET https://api.goflightlabs.com/flights-schedules?iataCode=&type=

For Fiji Airways, pass iataCode=FJ and use type to distinguish departures vs. arrivals as required by your logic. You can then filter for CDG in your application using the airport code in each schedule’s departure.airport or arrival.airport.

curl example: Fiji Airways schedules you can filter for CDG

curl -G "https://api.goflightlabs.com/flights-schedules" \
  --data-urlencode "iataCode=FJ" \
  --data-urlencode "type=arrival" \
  --data-urlencode "api_key=YOUR_API_KEY"

Notes:

• Replace YOUR_API_KEY with your FlightLabs key.
• Use type=arrival or type=departure depending on your use case.
• Filter locally for arrival.airport === "CDG" or departure.airport === "CDG" to isolate Charles de Gaulle operations.

What a schedule response looks like

Below is an official example structure for the schedules category. You’ll receive a list of schedules with departure/arrival blocks, terminals, and basic airline metadata.

{
    "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 you’ll use most often:

• flight_number: Combine with airline.iata to identify a unique marketed flight (e.g., FJ + number).
• departure.airport and arrival.airport: IATA codes; filter for CDG here.
• departure.scheduled and arrival.scheduled: ISO 8601 UTC timestamps. Convert to local time zones in your UI.
• terminal: When present, map to airport terminal displays for CDG.
• airline.iata: Confirms carrier is FJ.

Parsing Fiji Airways schedules for CDG in Python

This example requests Fiji Airways schedules and filters for CDG arrivals. It surfaces times in UTC and shows how to read terminals. You can adapt it for departures by switching the filter to departure.airport.

import requests
from datetime import datetime, timezone

API_URL = "https://api.goflightlabs.com/flights-schedules"
API_KEY = "YOUR_API_KEY"

def iso_to_local(iso_ts, tzinfo=timezone.utc):
    # Schedules are delivered in UTC per the example; adjust in your UI as needed.
    return datetime.fromisoformat(iso_ts.replace("Z", "+00:00")).astimezone(tzinfo)

params = {
    "iataCode": "FJ",
    "type": "arrival",
    "api_key": API_KEY
}

resp = requests.get(API_URL, params=params, timeout=30)
resp.raise_for_status()
payload = resp.json()

cdg_rows = []
if payload.get("success") and "data" in payload and "schedules" in payload["data"]:
    for s in payload["data"]["schedules"]:
        arr = s.get("arrival", {})
        dep = s.get("departure", {})
        airline = s.get("airline", {})
        if arr.get("airport") == "CDG" and airline.get("iata") == "FJ":
            cdg_rows.append({
                "carrier": airline.get("iata"),
                "flight_number": s.get("flight_number"),
                "dep_airport": dep.get("airport"),
                "dep_scheduled_utc": dep.get("scheduled"),
                "dep_terminal": dep.get("terminal"),
                "arr_airport": arr.get("airport"),
                "arr_scheduled_utc": arr.get("scheduled"),
                "arr_terminal": arr.get("terminal"),
                "aircraft_type": (s.get("aircraft") or {}).get("type"),
                "registration": (s.get("aircraft") or {}).get("registration")
            })

for row in cdg_rows:
    print(
        f"{row['carrier']}{row['flight_number']} "
        f"{row['dep_airport']}->{row['arr_airport']} "
        f"arrives {row['arr_scheduled_utc']} UTC "
        f"term {row['arr_terminal'] or '-'}"
    )

Tips:

• Keep timestamps in UTC for storage, convert to Europe/Paris in the UI if you need local display.
• Terminals may be missing depending on the data source; always null-check.
• If you paginate through schedules, follow the documentation for page cursors or offsets as applicable.

Adding live status and positions for Fiji Airways at CDG

After you render schedules, you’ll often layer status (scheduled, en-route, landed, canceled), gates, and real-time positions. The real-time tracking category returns structured data like this:

{
    "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 your CDG integration:

• flight.status: Drive the state machine for your board (scheduled, en-route, landed, canceled, diverted when applicable).
• departure.actual vs. arrival.estimated: Compute rolling delays and ETAs relative to scheduled times.
• departure.terminal/gate and arrival.terminal/gate: Populate CDG terminal panels. Null-check because not all flights will include gates early.
• position: Show the map pin or progress indicator on route to CDG.
• iata + number: Match a real-time item back to a schedule row (e.g., FJ + flight number).

For the exact live status and tracking endpoints, see the real-time section in the Documentation. You’ll use the same API key and JSON parsing patterns as in the schedule example.

Comparing endpoints for the Fiji Airways at CDG use case

Category	What it’s best at	Key fields you’ll use	When to call
Flight Schedules	Planned Fiji Airways operations; daily/weekly board builds	flight_number, airline.iata, departure/arrival.airport, scheduled, terminal	Once every schedule update cycle; cache aggressively
Real-time Tracking	Status, ETAs, gates, positions for FJ flights inbound/outbound CDG	status, departure.actual, arrival.estimated, terminal, gate, position	Poll when a flight is active; back-off when status stabilizes
Future Flights	Forward planning for CDG calendars and booking windows	Similar timing fields to schedules; often farther horizon	Daily job or on-demand fetch by date window
Flight History	Post-day reconciliation and analytics for Fiji Airways performance	Historical scheduled/actual/estimated timestamps	Batch jobs; archive to your warehouse
Routes	Carrier network references and CDG connectivity checks	Airline code, origin/destination pairs	Occasional refresh; low-change dataset

Three CDG-focused use cases for Fiji Airways data

1) Flight status boards for arrivals and departures

Start with schedules to build the board for FJ flights, then overlay live status:

• Schedules: departure.scheduled, arrival.scheduled, terminal power the base table.
• Real-time: status, departure.actual, arrival.estimated, gate enable countdown timers and “Now Boarding” displays.
• Matching: combine airline.iata and flight_number to merge schedule rows with live updates.

2) Delay and disruption monitoring

Compute delays by comparing scheduled vs. actual/estimated:

• Departure delay = departure.actual - departure.scheduled when both are present.
• Arrival delay = arrival.estimated - arrival.scheduled for in-flight; use actual when landed.
• Alerting threshold: when a delay exceeds your SLA, flag the FJ flight on the CDG dashboard.

If a flight is canceled or diverted, update the status immediately and suppress gate/terminal expectations. Handle missing values by defaulting to “TBD”.

3) Route and schedule analysis for product planning

Use the schedules and routes categories to check when Fiji Airways is scheduled to serve CDG and what connections exist.

• Filter schedules for arrival.airport === "CDG" or departure.airport === "CDG" to isolate relevant service.
• Use route references to understand possible origin/destination pairs for CDG planning.
• Feed results to a search index or analytics store alongside airline.iata and flight_number.

Handling time zones, polling, caching, and edge cases

• Time zones: API timestamps in the examples are ISO 8601 UTC (e.g., 2024-03-20T08:00:00Z). Store UTC server-side and convert to Europe/Paris only for the UI. Always show the time zone label in end-user views.
• Polling: For real-time flights that are “en-route”, poll more often; when a flight is “landed” or “canceled”, back-off or stop polling. Schedules can be cached more aggressively (e.g., refresh in batch by operating day).
• Caching: For immutable historical items, set long TTLs. For active flights, keep short TTLs and support client-side de-duplication by flight key (airline + flight number + date).
• Canceled/diverted: When status indicates these cases, hide gates and mark the row clearly. Store the status change time to audit downstream notifications.
• Codeshares: Use airline.iata to ensure you show Fiji Airways as the marketing carrier. If you merge multiple feeds, prefer the FJ-marketed record for consistency in your UI.
• Pagination: If your query spans many Fiji Airways flights, use the pagination scheme described in the documentation to iterate through pages and aggregate results.

End-to-end example: from Fiji Airways schedules to a CDG arrivals panel

1. Fetch schedules with /flights-schedules?iataCode=FJ&type=arrival.
2. Filter where arrival.airport === "CDG" and sort by arrival.scheduled.
3. For each result, try to match a live tracking item by carrier and flight number to retrieve status, arrival.estimated, and the arrival gate.
4. Compute delay = estimated - scheduled for en-route flights; format to minutes.
5. Render the table with UTC times under the hood and Europe/Paris on screen, keeping both available for debugging.

Operational and business notes

• Authentication: Use your FlightLabs API key for all requests. Manage keys and quotas in MCP.
• Onboarding and pricing: You can start with a trial (7 days or 50 requests) and move to paid plans as needed; see the website for current options. Starter plans begin at $24.99/month.
• Integration: Because the API returns JSON with predictable shapes across categories, you can reuse mappers for schedules and real-time with minor differences (e.g., estimated vs. actual fields).
• Reliability: Build idempotent ingestion and retry logic. It’s common for gate or ETA fields to update multiple times during taxi-out/in phases.

Explore more capabilities on FlightLabs, and sign up for a key at Register.

FAQ

• How do I isolate only Fiji Airways flights operating at CDG? Use the schedules endpoint with iataCode=FJ, then filter by arrival.airport === "CDG" or departure.airport === "CDG" in your application.
• What time zone are the timestamps? Examples are ISO 8601 UTC. Convert to Europe/Paris for display, but keep UTC internally for calculations and storage.
• How should I poll for live updates? Poll more frequently when status indicates an active phase (e.g., en-route) and back off once the flight lands or cancels. Cache schedules for longer intervals.
• How do I handle canceled or diverted flights? Use the status field from the real-time tracking data to switch UI state and suppress gates/ETAs. Keep a record of the transition time to avoid duplicate alerts.
• What if I need to paginate schedules? Follow the pagination instructions in the Documentation; aggregate pages server-side before sending to the client.

Build your Fiji Airways at CDG features with schedules, live status, and history, all from one API. Get started now by visiting FlightLabs and creating an API key via Register.