Every flight. The right connection.

Localized flight-master data and navigation helpers for World of Warcraft.
Find a nearby taxi, inspect its requirements, or build flight-aware addons with a reusable API.

LibTaxiData is a standalone multi-client addon and a shared data source for other addons, including Azeroth Pilot Reloaded. It works without LibStub, HereBeDragons, or any other addon. The same public API exposes localized taxi names, generated DB2 records, character conditions, coordinates, nearby nodes, and native Blizzard waypoints.

Get started  ·  Features  ·  Clients  ·  Commands  ·  API  ·  Data  ·  Support

---

Getting started

01   Install your version Download the release for your game client from CurseForge. LibTaxiData has no addon dependencies. Installing manually? Place the LibTaxiData folder in Interface/AddOns, then enable it on the character selection screen.	02   Find your next flight Type /ltd nearest to find a nearby taxi node that passes the default availability and visibility filters. The command prints its name and distance, then attempts to set a native Blizzard waypoint.
03   Inspect a flight master Use /ltd node <nodeID> for coordinates, conditions, flags, mounts, and visual metadata. Add a map ID to request local map coordinates. Need just the name? Use /ltd name <nodeID>. Type /ltd or /ltd help for the command list.	04   Build with the data Other addons access _G.LibTaxiData_API after LibTaxiData has loaded. Use the public methods for names, node details, searches, and coordinate conversion. Declare LibTaxiData as a dependency in your addon's TOC when your addon requires it.

Tip: Local coordinates in chat commands accept normalized values (0.438 0.682) or percentages (43.8 68.2). Coordinate APIs use normalized map values. Native waypoints and map conversions depend on the APIs available in your game client and on finding a compatible map.

---

Features

Localized names  ·  Character-aware data  ·  Navigation helpers  ·  A shared API

Flight data in your language Localized taxi names for all 12 supported client locales, selected automatically from the active game language. English fallback applied during data generation when a translated name is missing. Stable node IDs let addons look up the same flight master across languages. Localized chat output for node details, search results, help, and waypoint errors.	Complete node records Raw generated DB2 metadata: world positions, map and flight-map offsets, flags, textures, facing, and faction mounts. Enriched node details combine the raw record with its localized name, coordinate formats, availability, visibility, and faction mount. Condition references include availability, world-map visibility, and special-icon requirements. Excluded-node audit records retain the name and reason for deliberately omitted test or development nodes.
Results that fit your character Faction and character checks cover supported race, class, level, quest, reputation, item, spell, achievement, covenant, and ModifierTree requirements. Separate availability and visibility checks distinguish using a node from displaying it on the map. Three-state evaluation returns satisfied, rejected, or unknown when the public game API cannot evaluate a requirement. Configurable search filters let addon authors control unavailable, hidden, arrival-only, ignored, and unknown nodes.	Coordinates and navigation Nearest-node searches from the player, a map position, conventional world coordinates, or APR's historical coordinate format. Distance in yards, with optional three-dimensional distance and custom filters through the API. Map and world conversion with explicit coordinate-system fields and HereBeDragons-style convenience signatures. Native Blizzard waypoints resolve nodes on a preferred or current map and its parents, with super-tracking when available.
The right data for your client Automatic profile selection uses the detected client build and WoW project, including branches that share a project ID. Separate client and server catalogs describe permanent client versions and their Live, PTR, Beta, or archived data profiles. Explicit fallback reporting identifies when an installed archive uses its compatible fallback on an ungenerated build. Capability checks and modern/legacy API adapters account for differences between game clients.	Lightweight releases, reusable API One compatible data set per release archive, rather than shipping every generated client database. Complete data fingerprints group builds only when their node, condition, and locale data match. A standalone global API that consumers can check by capability, without a LibStub major or minimum data-version constant. Generated data and tooling keep the runtime manifest, interface metadata, release plan, and profile catalogs synchronized.

Supported languages

enUS, enGB, deDE, esES, esMX, frFR, itIT, koKR, ptBR, ruRU, zhCN, and zhTW.

Clients and compatibility

Client family	Data coverage in the current catalog
Retail	Live and PTR profiles with their own generated node, condition, and locale data.
Mists of Pandaria Classic	Live and PTR profiles.
Classic Era	A dedicated Live profile and generated data set.
WoW Forever	A dedicated Beta profile and generated data set.
Anniversary / Burning Crusade Classic	A dedicated TBC data set; the current catalog uses a PTR profile.
Wrath of the Lich King Classic	Registered as a base client; no active data profile is attached.
Cataclysm Classic	Registered as a base client; no active data profile is attached.

Install the published archive that matches your client. Registered base clients without a generated data profile are recognized but report supported = false. A generated PTR or Beta profile is published only when its release rules allow it; catalog coverage does not imply that every profile has a currently published prerelease.

Addon authors can inspect the selected profile, embedded data set, detected build, exact/fallback state, and API capabilities through GetClientInfo().

---

Commands

Use /ltd or /libtaxidata in chat. Both prefixes open the same commands. LibTaxiData's controls are available through chat commands and its public API.

Command	What it does
/ltd / /ltd help	Print the command list.
/ltd name <nodeID>	Print the localized node name and its ID.
/ltd node <nodeID> [uiMapID]	Print the node's localized name, world/APR coordinates, conditions, flags, mounts, offsets, and visual metadata; include map coordinates when a map ID can be resolved. details is an alias.
/ltd nearest	Find the nearest node using the default availability and visibility filters, print its name and distance, and attempt to set a waypoint.
/ltd nearest <uiMapID> <x> <y>	Search from normalized or percentage map coordinates and attempt to set a waypoint.
/ltd nearest world <instanceID> <worldX> <worldY>	Search from conventional world coordinates and attempt to resolve the result on the current map hierarchy.
/ltd waypoint <nodeID> [uiMapID]	Set a native Blizzard waypoint for the node, using the preferred map when provided; enable super-tracking when available.

Examples:

/ltd nearest
/ltd name 2
/ltd node 2 84
/ltd waypoint 2 84
/ltd nearest 2437 43.8 68.2

Important: A nearest-node result reflects the library's data and character filters. Requirements that depend on unknown server-side state remain unknown and are eligible by default. Use the API option includeUnknown = false if your addon needs to reject nodes with unknown availability.

---

Public API

The addon exposes _G.LibTaxiData_API. It does not register a LibStub major and there is no minimum data-version constant for consumers to maintain.

Load LibTaxiData before your addon

When LibTaxiData is required, declare it in your addon's TOC:

## Dependencies: LibTaxiData

Consumers should check the public methods they use and inspect GetClientInfo().supported when deciding whether flight data is available for the detected client.

local taxi = _G.LibTaxiData_API

local name = taxi.GetNodeName(2)
local raw = taxi.GetAllNodeData(2)
local details = taxi.GetNodeDetails(2, 84)

local nearest = taxi.FindNearestNodeToPlayer()
if nearest then
    taxi.SetWaypointToNode(nearest.nodeID)
end

Node data

API	Result
GetNode(nodeID) / GetAllNodeData(nodeID)	Raw generated TaxiNodes record with every retained DB2 field.
GetAllNodes()	Raw node table keyed by node ID.
GetNodeDetails(nodeID[, uiMapID])	Copy of all raw fields enriched with nodeID, localized name, world/APR/map positions, availability, visibility, and faction mount.
GetNodeName(nodeID)	Name for the active WoW client locale.
GetNodeWorldPosition(nodeID[, format])	Standard world-position object, or APR format when format is "apr-world".
GetNodeAPRWorldPosition(nodeID)	APR's historical swapped-axis world-position object.
GetNodeMapPosition(nodeID, uiMapID[, allowOutOfBounds])	Node position normalized to 0..1 on the requested UI map.
IterateNodes()	next iterator over retained nodes.
GetExcludedNode(nodeID)	Excluded development-node name and audit reason.
GetSource()	Current build, provider, DB2 table, and row counts.
GetClientInfo()	Selected profile/data set, game type, channel, detected build, and exact/fallback selection state.

Node conditions and mounts

API	Result
GetPlayerCondition(conditionID)	Raw generated PlayerCondition record, or nil when it is not retained.
IsNodeAvailable(nodeID)	Whether the node's faction and availability requirements pass; nil when required state cannot be evaluated.
IsNodeVisible(nodeID)	Whether the node should appear for the character according to faction, visibility conditions, and flags.
HasSpecialIcon(nodeID)	Whether the node's conditional special icon applies.
EvaluatePlayerCondition(conditionID)	Three-state evaluation of a PlayerCondition.
EvaluateModifierTree(treeID)	Three-state evaluation of a supported ModifierTree.
GetMountCreatureID(nodeID)	The current faction's taxi mount creature ID when one is defined.

Coordinate formats

Every object contains a coordinateSystem field. The names are also available through API.COORDINATE_FORMATS.

Format	Shape	Meaning
world	{ x = worldX, y = worldY, z, instanceID }	Conventional TaxiNodes/HereBeDragons world coordinates in yards.
apr-world	{ x = worldY, y = worldX, z, instanceID }	APR's historical storage format, matching the return order handled from UnitPosition.
map	{ x = 0..1, y = 0..1, mapID, instanceID }	Normalized coordinates on a specific UI map.

The conversions use the clients' native C_Map API. Object-returning methods are preferred because they preserve the coordinate system explicitly:

local world = taxi.MapToWorld(2437, 0.438, 0.682)
local localPosition = taxi.WorldToMap(
    world.instanceID,
    world.x,
    world.y,
    2437
)

For easy migration, the library also exposes HereBeDragons-style signatures:

local worldX, worldY, instanceID =
    taxi.GetWorldCoordinatesFromZone(0.438, 0.682, 2437)

local mapX, mapY = taxi.GetZoneCoordinatesFromWorld(worldX, worldY, 2437)
local sameMapX, sameMapY =
    taxi.GetZoneCoordinatesFromWorldInstance(worldX, worldY, instanceID, 2437)

Coordinate conversion helpers

API	Result
MapToWorld(uiMapID, mapX, mapY)	Convert normalized map coordinates to a conventional world-position object.
WorldToMap(instanceID, worldX, worldY, uiMapID[, allowOutOfBounds])	Convert world coordinates to normalized coordinates on the requested UI map.
GetPlayerWorldPosition()	The player's conventional world-position object when it can be resolved.
WorldToAPRWorld(worldX, worldY, worldZ, instanceID)	Convert conventional world X/Y to APR's historical swapped-axis position object.
APRWorldToWorld(aprX, aprY, worldZ, instanceID)	Convert an APR position back to a conventional world-position object.
GetWorldCoordinatesFromZone(mapX, mapY, uiMapID)	Return conventional worldX, worldY, and instanceID.
GetZoneCoordinatesFromWorld(worldX, worldY, uiMapID[, allowOutOfBounds])	Return normalized mapX, mapY, and mapID, inferring the target world instance.
GetZoneCoordinatesFromWorldInstance(worldX, worldY, instanceID, uiMapID[, allowOutOfBounds])	Return normalized mapX, mapY, and mapID with an explicit world instance.

Nearest-node searches

API	Origin format
FindNearestNodeToPlayer([options])	Current player position.
FindNearestNodeFromMap(uiMapID, x, y[, options])	Local normalized map coordinates.
FindNearestNodeFromWorld(worldX, worldY, instanceID[, options])	Conventional world coordinates.
FindNearestNodeFromAPRWorld(aprX, aprY, instanceID[, options])	APR swapped-axis world coordinates.

A successful search returns nodeID, raw node, localized name, distance in yards, both world formats, availability, visibility, and the origin when it is known. By default the search excludes known-unavailable, hidden, END_POINT_ONLY, and IGNORE_FOR_FIND_NEAREST nodes. An unevaluable server-only condition remains eligible instead of being incorrectly rejected.

The optional table supports includeUnavailable, includeUnknown = false, includeHidden, includeEndpointOnly, includeIgnored, threeDimensional, z, and a custom filter(nodeID, node, availability, visibility) callback.

Native waypoints

API	Result
ResolveNodeMapPosition(nodeID[, preferredMapID])	Find the node's normalized position on a preferred or current map, checking parent maps as needed. Returns nil and an error code when no map can be resolved.
SetWaypointToNode(nodeID[, preferredMapID])	Set a native Blizzard waypoint and enable super-tracking when available. Returns true and the map position on success, or false and an error code on failure.

Map conversion, player-position lookup, and native waypoints depend on client API capabilities. A successful nearest-node search does not guarantee that a waypoint can be placed on the current map hierarchy.

Conditions

IsNodeAvailable, IsNodeVisible, EvaluatePlayerCondition, and EvaluateModifierTree use tri-state results:

• true: all known requirements pass;
• false: at least one requirement is known to fail;
• nil: the public addon API cannot safely evaluate a server-only requirement.

The library never turns an unknown phase, WorldStateExpression, objective, AreaTable, or other server-only state into a false positive.

Data profiles and generation

Client detection selects the profile from GetBuildInfo() and WOW_PROJECT_ID. profile describes the client build, while dataSet identifies the data shipped in the installed archive. GetClientInfo() reports the selected profile, exact/fallback state, support status, and available API capabilities.

The generator uses Blizzard's public build feed and versioned Wago Tools DB2 exports. It keeps client profiles, generated data, and TOC interfaces synchronized. Release archives include one compatible data set; builds share storage only when their complete node, condition, and locale fingerprints match.

python tools/profiles.py list
python tools/profiles.py check
python tools/package.py --matrix

See the data-generation guide for adding base clients or server profiles, regenerating data, API adapters, release-channel rules, archived builds, and packaging commands.

---

Support and contributions

Read the source and report an issue Browse the GitHub repository for the API, generated data, tests, and build tooling. Report bugs or request improvements through GitHub Issues. Include your addon version, game client and build, node or map IDs, the command or API call, and any Lua error.

Join the community Visit Discord for setup help, API discussions, and translation contributions. For client-selection or data problems, include the result of GetClientInfo() and GetSource() so the selected profile and data source can be identified.

---

Credits

Development Neoldric Addon development, public API, and data tooling. Built for the World of Warcraft addon community and the Azeroth Pilot Reloaded projects.

Data and tooling Blizzard Entertainment - World of Warcraft client APIs and public build feed. Wago Tools - Versioned DB2 exports.

---

LibTaxiData
Flight data for your next connection.

Back to top