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.