Gate and Baggage Displays (GIDS & BIDS) — the Airport Screens Beyond the Main Board

The big departures board in the terminal is only the first screen a passenger reads. Two more matter just as much: the display at the gate that tells them whether boarding has started, and the screen over the baggage carousel that tells them where their suitcase will appear. Those are the Gate Information Display System (GIDS) and the Baggage Information Display System (BIDS), and they run on a small, specific slice of flight data — the gate, terminal and baggage-carousel fields. This guide explains what each screen shows and how to drive it from an API.

Sergey St.

Published on Aug 12th 26

Share:

• 
• 
• 

Beyond the Main Board: Where Gate and Baggage Displays Fit

The main terminal board — the Flight Information Display System (FIDS) — is a broad list of every departure or arrival at the airport. Gate and baggage displays are the opposite: narrow, local screens that show one thing very well.

A gate display shows the single flight (or next flight) leaving from that gate, with its boarding status. A baggage display shows which arriving flight's bags are on a given carousel. Same underlying flight data as the main board, but filtered down to one gate or one belt — and keyed on fields the main board often does not even show.

"The last two screens a passenger looks at are the smallest ones: the gate that says 'boarding', and the belt number that says 'your bag is here'. Both are one field of flight data, shown at the right place."

Gate Information Display Systems (GIDS)

A gate display answers one question for the people standing in front of it: is this the right gate, and what is happening with the flight? It shows the flight number and destination, the scheduled and estimated departure time, the boarding status, and the gate and terminal themselves.

The data behind it is a departure schedule narrowed to a single gate. The fields that matter are dep_gate and dep_terminal to place the flight, dep_time and dep_estimated for the scheduled and updated departure, and status for the boarding state. Pull the airport's departures, filter to the gate, and you have a gate display.

Baggage Information Display Systems (BIDS)

A baggage display sits above each reclaim carousel and tells arriving passengers which belt to wait at. It shows the flight number and where the flight came from, the carousel number, and whether the bags are on their way.

Here the key field is arr_baggage — the baggage-claim carousel number — alongside arr_terminal to locate the hall, the origin airport (dep_iata) so passengers recognise their flight, and status and arr_time / arr_estimated for timing. A baggage display is an arrivals schedule grouped by carousel instead of by time.

The Data Behind Gate and Baggage Displays

Both screens come from the same two AirLabs endpoints. The Schedules API returns an airport's departures and arrivals with the gate, terminal and baggage fields on each flight — which is exactly what a display needs. The Flight Information API returns the same fields for a single flight looked up by number, for a "what gate / which carousel" query.

The relevant fields, straight from the schedule response:

A departures pull for a gate display looks like this:

GET https://airlabs.co/api/v9/schedules?dep_iata=MIA&api_key={KEY}

[{
  "flight_iata": "BA6984",
  "dep_iata": "MIA",
  "arr_iata": "SFO",
  "dep_terminal": "C",
  "dep_gate": "E4",
  "dep_time": "2026-05-14 19:53",
  "dep_estimated": "2026-05-14 22:10",
  "status": "scheduled"
}]

And an arrivals pull for a baggage display carries the carousel:

GET https://airlabs.co/api/v9/schedules?arr_iata=SFO&api_key={KEY}

[{
  "flight_iata": "BA6984",
  "dep_iata": "MIA",
  "arr_iata": "SFO",
  "arr_terminal": "1",
  "arr_gate": "B24",
  "arr_baggage": "1",
  "arr_time": "2026-05-14 22:52",
  "arr_estimated": "2026-05-15 01:09",
  "status": "scheduled"
}]

The Honest Boundary: Availability and Change

Gate and baggage assignments are the most volatile data on the board, and it is worth building for that from the start. These values are provided where the airport and its sources publish them — not every airport, and not every flight, has a gate or a carousel attached, so a display has to handle a missing dep_gate or arr_baggage gracefully rather than showing a blank. They are also frequently estimated and subject to change: a gate can move and a carousel can be reassigned right up to arrival. The API gives you the current best value and the updated times (dep_estimated, arr_estimated); your display should refresh on a short interval and re-render when they change, exactly as a real airport screen does.

Building a Gate or Baggage Display

A gate display

Request the airport's departures from the Schedules API, filter the results to the gate (dep_gate, optionally with dep_terminal), sort by dep_time, and render the flight, destination, boarding status and the estimated time. Poll on a short interval so the boarding state stays live.

A baggage display

Request the airport's arrivals, group the flights by arr_baggage, and for each carousel show the flight number, the origin (dep_iata), the status and the arrival time. Passengers scan for their origin city, so surface that clearly.

A single-flight lookup

For a "what gate is my flight / which belt is my bag" feature, call the Flight Information API with the flight_iata and read dep_gate, arr_gate and arr_baggage directly — no filtering required.

Practical Patterns for Gate and Baggage Data

• Handle missing values gracefully. Not every flight has a gate or carousel assigned; render a clean "—" or hide the row rather than showing an empty field.
• Treat gate and carousel as provisional. They change late; poll on a short interval and re-render when dep_estimated / arr_estimated or the assignment updates.
• Request only what the screen needs with _fields (for example flight_iata,dep_iata,arr_baggage,status) to keep a wall-mounted display lightweight.
• Resolve airport codes to names through the Airports Database so a baggage screen can show "Miami" rather than "MIA".

Gate and Baggage Data for Developers

If you are building airport signage, a terminal companion app or a "where's my gate / where's my bag" feature, the AirLabs API gives you the gate, terminal and baggage-carousel fields alongside live status and times — from the Schedules API for whole-airport displays and the Flight Information API for single-flight lookups, through one integration.

Supported API Features

Our Developer API allows you to create a custom experience for your users and increase the value of your product:

• Schedules API for airport departures and arrivals with dep_gate, arr_gate, dep_terminal, arr_terminal and arr_baggage.
• Flight Information API for a single flight's gate, terminal and baggage carousel by flight number.
• Scheduled and estimated times plus status for live boarding and arrival state.
• Airports Database to resolve IATA/ICAO codes into airport names and details.
• Airlines Database to turn carrier codes into names and logos.
• Field selection via _fields, plus JSON, XML and CSV formats behind a single API key.

You can try it right now without any obligation! Get a free flight API plan and see for yourself that we have exactly the data you need!

If you need more information, don't hesitate to contact us. We are always happy to chat with our customers and are sure to find a customized solution for each request.