API v1.3.6

Wind Aloft API

Overview

The Wind Aloft API provides upper-level wind and temperature data at multiple flight levels for a list of waypoints along your flight route. Data is sourced from GRIB (GRIdded Binary) weather model files, providing accurate forecast data for flight planning and fuel calculations.

Data Sources

Wind aloft data is sourced from GFS (Global Forecast System) GRIB files, which are updated every 6 hours. The API returns wind direction, wind speed, and temperature at your cruise level and at ±2000ft and ±4000ft offsets, allowing for optimal altitude selection.

Developer Key Access

Access to the Wind Aloft API is controlled by your developer key configuration. This integration is available independently of the performance dataset and is free for all non-commercial projects. For commercial licensing, please contact us at info@virtualperformancetool.com.

FMS/FMGS Integration

The Wind Aloft API is the perfect endpoint to get real-world winds implemented inside your FMS/FMGS. Request your developer key by contacting us at info@virtualperformancetool.com.

Get Wind Aloft

POST /api

Retrieves wind and temperature data at multiple flight levels for a list of waypoints. Returns data at the cruise level as well as ±2000ft and ±4000ft altitude offsets.

Request Parameters

Parameter	Type	Required	Description
`query`	`string`	Required	Must be `"windAloft"`
`data.waypoints`	`array`	Required	Array of waypoint objects (see below)

Waypoint Object

Property	Type	Required	Description
`name`	`string`	Optional	Waypoint identifier (e.g., `"TOC"`, `"ARTIP"`)
`latitude`	`number`	Required	Latitude in decimal degrees (-90 to 90)
`longitude`	`number`	Required	Longitude in decimal degrees (-180 to 180)
`cruiseLevel`	`integer`	Required	Flight level (e.g., `350` for FL350)
`eto`	`string \| integer`	Optional	Estimated Time Over - ISO 8601 datetime or Unix timestamp. Used to select appropriate forecast data. Defaults to current time if omitted.

Request Body

JSON

{
  "query": "windAloft",
  "data": {
    "waypoints": [
      {
        "name": "TOC",
        "latitude": 50.9014,
        "longitude": 4.4844,
        "cruiseLevel": 350,
        "eto": "2026-03-20T14:30:00Z"
      },
      {
        "name": "ARTIP",
        "latitude": 50.3456,
        "longitude": 3.2158,
        "cruiseLevel": 350,
        "eto": "2026-03-20T15:00:00Z"
      },
      {
        "name": "TOD",
        "latitude": 49.0123,
        "longitude": 2.5500,
        "cruiseLevel": 350,
        "eto": "2026-03-20T15:30:00Z"
      }
    ]
  }
}

cURL Example

cURL

curl -X POST "https://api.virtualperformancetool.com/api" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -H "X-API-Version: 1.3.6" \
  -d '{
    "query": "windAloft",
    "data": {
      "waypoints": [
        {
          "name": "TOC",
          "latitude": 50.9014,
          "longitude": 4.4844,
          "cruiseLevel": 350,
          "eto": "2026-03-20T14:30:00Z"
        }
      ]
    }
  }'

Response

JSON

{
  "apiVersion": "1.3.6",
  "windAloft": [
    {
      "name": "TOC",
      "latitude": 50.9014,
      "longitude": 4.4844,
      "cruiseLevel": 350,
      "eto": "2026-03-20T14:30:00Z",
      "forecastHour": 6,
      "cruiseTemperature": -52.3,
      "winds": {
        "plus4000": {
          "flightLevel": 390,
          "altitude": 39000,
          "windDirection": 275,
          "windSpeed": 85,
          "temperature": -56.1
        },
        "plus2000": {
          "flightLevel": 370,
          "altitude": 37000,
          "windDirection": 272,
          "windSpeed": 78,
          "temperature": -54.2
        },
        "cruise": {
          "flightLevel": 350,
          "altitude": 35000,
          "windDirection": 268,
          "windSpeed": 72,
          "temperature": -52.3
        },
        "minus2000": {
          "flightLevel": 330,
          "altitude": 33000,
          "windDirection": 265,
          "windSpeed": 65,
          "temperature": -48.7
        },
        "minus4000": {
          "flightLevel": 310,
          "altitude": 31000,
          "windDirection": 260,
          "windSpeed": 58,
          "temperature": -45.1
        }
      }
    }
  ]
}

Response Fields

Waypoint Response Object

Field	Type	Description
`name`	`string`	Waypoint identifier from the request
`latitude`	`number`	Latitude in decimal degrees
`longitude`	`number`	Longitude in decimal degrees
`cruiseLevel`	`integer`	Requested flight level
`eto`	`string \| integer \| null`	Estimated Time Over from the request (null if not provided)
`forecastHour`	`integer`	GRIB forecast hour used (0, 6, 12, 18, 24, 30, 36, 42, or 48)
`cruiseTemperature`	`number \| null`	Temperature at cruise level in °C
`winds`	`object`	Wind data at multiple altitudes (see below)

Winds Object

The winds object contains wind and temperature data at five altitude levels relative to the cruise level:

Key	Description
`plus4000`	Cruise level + 4000ft (e.g., FL390 for FL350 cruise)
`plus2000`	Cruise level + 2000ft (e.g., FL370 for FL350 cruise)
`cruise`	Cruise level (e.g., FL350)
`minus2000`	Cruise level - 2000ft (e.g., FL330 for FL350 cruise)
`minus4000`	Cruise level - 4000ft (e.g., FL310 for FL350 cruise)

Wind Level Object

Field	Type	Description
`flightLevel`	`integer`	Flight level (e.g., 350)
`altitude`	`integer`	Altitude in feet (e.g., 35000)
`windDirection`	`integer \| null`	Wind direction in degrees true (0-360)
`windSpeed`	`integer \| null`	Wind speed in knots
`temperature`	`number \| null`	Temperature in °C

Null Values

Wind and temperature values may be null if the requested altitude level is outside the available GRIB data range, or if GRIB data is temporarily unavailable. Your application should handle null values gracefully.

Usage Examples

JavaScript/TypeScript

JavaScript

async function getWindAloft(waypoints, token) {
  const response = await fetch('https://api.virtualperformancetool.com/api', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
      'X-API-Version': '1.3.6'
    },
    body: JSON.stringify({
      query: 'windAloft',
      data: { waypoints }
    })
  });

  const data = await response.json();
  return data.windAloft;
}

// Example: Get winds for route waypoints
const waypoints = [
  { name: 'TOC', latitude: 50.9014, longitude: 4.4844, cruiseLevel: 350 },
  { name: 'ARTIP', latitude: 50.3456, longitude: 3.2158, cruiseLevel: 350 },
  { name: 'TOD', latitude: 49.0123, longitude: 2.5500, cruiseLevel: 350 }
];

const winds = await getWindAloft(waypoints, jwtToken);

// Find optimal altitude based on headwind
for (const waypoint of winds) {
  console.log(`${waypoint.name}: Cruise temp ${waypoint.cruiseTemperature}°C`);
  
  for (const [level, data] of Object.entries(waypoint.winds)) {
    if (data.windSpeed) {
      console.log(`  ${level}: ${data.windDirection}°/${data.windSpeed}kt @ FL${data.flightLevel}`);
    }
  }
}

Swift

struct Waypoint: Codable {
    let name: String?
    let latitude: Double
    let longitude: Double
    let cruiseLevel: Int
}

struct WindLevel: Codable {
    let flightLevel: Int
    let altitude: Int
    let windDirection: Int?
    let windSpeed: Int?
    let temperature: Double?
}

struct WaypointWinds: Codable {
    let name: String
    let latitude: Double
    let longitude: Double
    let cruiseLevel: Int
    let cruiseTemperature: Double?
    let winds: [String: WindLevel]
}

func getWindAloft(waypoints: [Waypoint]) async throws -> [WaypointWinds] {
    let request = [
        "query": "windAloft",
        "data": ["waypoints": waypoints]
    ] as [String: Any]
    
    // Make API request...
    let response = try await apiClient.post(request)
    return response.windAloft
}