QFX Talent Data

QFX Talent Data is a public World of Warcraft Retail talent database designed for use by other addons.

It provides global Mythic+ and Heroic/Mythic raid talent samples, recommended talent import strings, and season metadata through the global Lua API:

_G.QFXTalentData

Data Provided

The database contains:

Current-season Mythic+ dungeons
Current-season raids and encounters
English, Simplified Chinese, and Traditional Chinese names
Stable IDs and slugs for dungeons, raids, and encounters
Talent data for all Retail specializations
Valid Blizzard talent import strings
Raw ranking samples for every available content and specialization combination
A recommended import string selected from the collected samples
Valid sample counts and configured source limits
Database version, generation time, season, and source metadata
Separate Heroic and Mythic raid datasets

Mythic+ data is collected from global Raider.IO specialization rankings.

Raid data is collected from global Warcraft Logs rankings.

Raid difficulty IDs are stored separately:

4 — Heroic
5 — Mythic

When no valid public data is available for a specialization, encounter, or difficulty, the API returns nil. Data from another difficulty is never silently substituted.

Public API

Access the database through:

local API = _G.QFXTalentData

Current API version:

API.apiVersion == 1

Activating Specialization Data

The current character specialization is activated automatically when the database loads.

An addon may also activate it explicitly:

local ok, reason = API:ActivateCurrentSpec()

To activate a specific specialization:

local ok, reason = API:ActivateSpec(specID)

Only one specialization is expanded into runtime tables at a time. Activating another specialization releases the previously active specialization data.

Database Manifest

local manifest = API:GetManifest()

The manifest contains:

manifest.apiVersion
manifest.dataVersion
manifest.generatedAt
manifest.seasonName
manifest.seasonSlug
manifest.source
manifest.raidDifficulties
manifest.dungeons
manifest.raids

Example dungeon enumeration:

for _, dungeon in ipairs(manifest.dungeons) do
    print(
        dungeon.id,
        dungeon.slug,
        dungeon.names.enUS,
        dungeon.names.zhCN,
        dungeon.names.zhTW
    )
end

Example raid and encounter enumeration:

for _, raid in ipairs(manifest.raids) do
    print(
        raid.id,
        raid.slug,
        raid.names.enUS
    )

    for _, boss in ipairs(raid.bosses) do
        print(
            boss.id,
            boss.slug,
            boss.names.enUS
        )
    end
end

Addon developers should use GetManifest() instead of hard-coding the available dungeon, raid, or encounter list.

Current Specialization

local specID = API:GetCurrentSpecID()

Complete Specialization Data

local specData = API:GetSpecData(specID)

Main data structure:

specData.dungeons[dungeonID]

specData.raids[raidID]
    .bosses[bossID]
    .difficulties[difficultyID]

Mythic+ Data

Retrieve the complete record for a dungeon:

local data =
    API:GetDungeonData(
        dungeonID,
        specID
    )

Returned fields:

data.recommended
data.sampleCount
data.samples
data.sourceRankLimit

Field descriptions:

recommended — Recommended Blizzard talent import string
sampleCount — Number of valid samples collected
samples — Array of raw talent import strings
sourceRankLimit — Configured source ranking sample limit

Retrieve the recommended string directly:

local talentCode, data =
    API:GetRecommendedDungeonTalent(
        dungeonID,
        specID
    )

Raid Encounter Data

Retrieve a raid encounter record:

local data =
    API:GetRaidData(
        raidID,
        bossID,
        difficultyID,
        specID
    )

The returned record uses the same fields:

data.recommended
data.sampleCount
data.samples
data.sourceRankLimit

Retrieve the recommended string directly:

local talentCode, data =
    API:GetRecommendedRaidTalent(
        raidID,
        bossID,
        difficultyID,
        specID
    )

Available Raid Difficulties

local difficulties =
    API:GetAvailableRaidDifficulties(
        raidID,
        bossID,
        specID
    )

Example result when both difficulties are available:

{ 4, 5 }

If only Heroic data is available:

{ 4 }

Releasing Specialization Data

Release the currently expanded specialization:

API:ReleaseActiveSpec()

Release it and request Lua garbage collection:

API:ReleaseActiveSpec(true)

Complete Usage Example

local API = _G.QFXTalentData
if not API or API.apiVersion ~= 1 then
    return
end

local specID = API:GetCurrentSpecID()
local ok, reason = API:ActivateSpec(specID)

if not ok then
    print("Unable to activate talent data:", reason)
    return
end

local manifest = API:GetManifest()
local dungeon = manifest.dungeons[1]

if dungeon then
    local talentCode, data =
        API:GetRecommendedDungeonTalent(
            dungeon.id,
            specID
        )

    if talentCode then
        print("Recommended talent:", talentCode)
        print("Valid samples:", data.sampleCount)

        for index, sample in ipairs(data.samples) do
            print(index, sample)
        end
    end
end

Addon Dependency

Addons that require this database may declare it in their TOC file:

## RequiredDeps: QFXTalentData

Addons that use it as an optional data source may declare:

## OptionalDeps: QFXTalentData

Always verify that the API and supported version are available:

local API = _G.QFXTalentData

if not API or API.apiVersion ~= 1 then
    return
end

Talent Selection Rates

The compact database does not store duplicated, precomputed talent-node selection tables.

Consumers can read the raw samples and calculate selection rates when needed:

local samples = data.samples

The following methods remain available for compatibility with older data packages, but may return nil with the current compact format:

API:GetDungeonSelectionRates(
    dungeonID,
    specID
)

API:GetRaidSelectionRates(
    raidID,
    bossID,
    difficultyID,
    specID
)

Data Updates

The database is generated by an automated collection pipeline.

Each release includes the following information in its manifest:

API version
Data version
UTC generation time
Current season
Data sources
Available dungeons
Available raids and encounters
Available raid difficulties

The available content and sample counts may change as the season progresses. Consumers should read the manifest dynamically and handle missing data gracefully.