@yaelouuu/fortnite-api 6.1.0 → 7.0.0

package/dist/resources/events.d.ts

@@ -1,5 +1,5 @@
 import { FortniteAPI } from "../client";
-import { EventWindows, PlayerEventHistory, TournamentDetails, ScoringRules, EventLeaderboard, PlayerEventData, EligibilityStatus, PlayerEligibilityResult, ArenaHype, EventRewards } from "../types";
+import { EventWindows, PlayerEventHistory, TournamentDetails, ScoringRules, EventLeaderboard, PlayerEventData, EventRewards, PlayerTokensResponse } from "../types";
 /**
  * Events Resource
  * Handles tournament and competitive events data
@@ -58,32 +58,13 @@ export declare class EventsResource {
      */
     getPlayerEventData(eventId: string, eventWindowId: string, accountId: string, fortniteToken?: string): Promise<PlayerEventData>;
     /**
-     * Get parsed tournament eligibility requirements.
-     * No user token needed — requirements are extracted from tournament metadata.
-     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
-     * @param eventWindowId - Optional: filter to a specific event window
-     * @returns Parsed eligibility requirements
+     * Get the raw token set for one or more players.
+     * Tokens are eligibility flags earned by participating in tournaments
+     * (e.g. qualifying tokens, ban tokens).
+     * No user token required — uses service auth.
+     * @param accountIds - One or more Epic account IDs
      */
-    checkEligibility(eventId: string, eventWindowId?: string): Promise<EligibilityStatus>;
-    /**
-     * Check a player's eligibility against tournament requirements.
-     * Cross-references ranked data with tournament requirements — no user token needed.
-     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
-     * @param accountId - Epic Games Account ID to check
-     * @param options - Optional platform and eventWindowId
-     * @returns Player eligibility check results
-     */
-    checkPlayerEligibility(eventId: string, accountId: string, options?: {
-        platform?: string;
-        eventWindowId?: string;
-    }): Promise<PlayerEligibilityResult>;
-    /**
-     * Get Arena hype and division
-     * @param accountId - Account ID
-     * @param fortniteToken - Optional user Fortnite token
-     * @returns Arena hype, division, and progress
-     */
-    getArenaHype(accountId: string, fortniteToken?: string): Promise<ArenaHype>;
+    getPlayerTokens(accountIds: string | string[]): Promise<PlayerTokensResponse>;
     /**
      * Get event rewards/prizes
      * @param eventId - Event ID

package/dist/resources/events.js

@@ -95,45 +95,16 @@ class EventsResource {
         return this.client.request(`/events/${eventId}/windows/${eventWindowId}/players/${accountId}`, { headers }, "v2");
     }
     /**
-     * Get parsed tournament eligibility requirements.
-     * No user token needed — requirements are extracted from tournament metadata.
-     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
-     * @param eventWindowId - Optional: filter to a specific event window
-     * @returns Parsed eligibility requirements
+     * Get the raw token set for one or more players.
+     * Tokens are eligibility flags earned by participating in tournaments
+     * (e.g. qualifying tokens, ban tokens).
+     * No user token required — uses service auth.
+     * @param accountIds - One or more Epic account IDs
      */
-    async checkEligibility(eventId, eventWindowId) {
-        const query = eventWindowId ? `?eventWindowId=${eventWindowId}` : "";
-        return this.client.request(`/events/${eventId}/eligibility${query}`, {}, "v2");
-    }
-    /**
-     * Check a player's eligibility against tournament requirements.
-     * Cross-references ranked data with tournament requirements — no user token needed.
-     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
-     * @param accountId - Epic Games Account ID to check
-     * @param options - Optional platform and eventWindowId
-     * @returns Player eligibility check results
-     */
-    async checkPlayerEligibility(eventId, accountId, options) {
-        const params = new URLSearchParams();
-        if (options?.platform)
-            params.set("platform", options.platform);
-        if (options?.eventWindowId)
-            params.set("eventWindowId", options.eventWindowId);
-        const query = params.toString() ? `?${params.toString()}` : "";
-        return this.client.request(`/events/${eventId}/eligibility/${accountId}${query}`, {}, "v2");
-    }
-    /**
-     * Get Arena hype and division
-     * @param accountId - Account ID
-     * @param fortniteToken - Optional user Fortnite token
-     * @returns Arena hype, division, and progress
-     */
-    async getArenaHype(accountId, fortniteToken) {
-        const headers = {};
-        if (fortniteToken) {
-            headers["x-fortnite-token"] = fortniteToken;
-        }
-        return this.client.request(`/events/arena/${accountId}`, { headers }, "v2");
+    async getPlayerTokens(accountIds) {
+        const ids = Array.isArray(accountIds) ? accountIds : [accountIds];
+        const qs = ids.map(encodeURIComponent).join("%2C");
+        return this.client.request(`/events/tokens?teamAccountIds=${qs}`, {}, "v1");
     }
     /**
      * Get event rewards/prizes

package/dist/resources/profiles.d.ts

@@ -1,15 +1,49 @@
 import { FortniteAPI } from "../client";
+import { ProfileLevel, RankedProgress, TrackDefinition } from "../types";
 export declare class ProfilesResource {
     private client;
     constructor(client: FortniteAPI);
     /**
-     * Get profile progress (track progress, levels) by display name
-     * @param displayName - Epic Games display name
+     * Get raw Habanero track progress for a single account. Public — no token required.
+     * @param accountId - Epic account ID
+     */
+    getProgress(accountId: string): Promise<any>;
+    /**
+     * Get a player's XP, level, accountLevel, and battle pass tier.
+     * Parsed from QueryProfile (profileId=athena) on the MCP service.
+     * Requires the player's own Fortnite OAuth token — cannot be used for other accounts.
+     * @param accountId - Epic account ID
+     * @param fortniteToken - User's Fortnite OAuth token (required)
      */
-    getProgress(displayName: string): Promise<any>;
+    getLevel(accountId: string, fortniteToken: string): Promise<ProfileLevel>;
     /**
-     * Get enriched ranked progress by display name (human-readable ranks, game modes, season dates)
+     * Get enriched ranked progress — human-readable rank names, game mode labels, season dates.
      * @param displayName - Epic Games display name
      */
-    getRanked(displayName: string): Promise<any>;
+    getRanked(displayName: string): Promise<RankedProgress[]>;
+    /**
+     * Get all available ranked game mode tracks — modes, division counts, and season dates.
+     * @param options - Optional filters
+     */
+    getTracks(options?: {
+        /** ISO 8601 — only return tracks ending before this date */
+        endsBefore?: string;
+        /** ISO 8601 — only return tracks ending after this date */
+        endsAfter?: string;
+    }): Promise<TrackDefinition[]>;
+    /**
+     * Get ranked track progress for multiple account IDs in one request (L3AGUE bulk endpoint).
+     * @param accountIds - Array of Epic account IDs
+     */
+    getBulkTrackProgress(accountIds: string[]): Promise<any[]>;
+    /**
+     * Get a Habanero game leaderboard centered around an account.
+     * @param gameId - Habanero game identifier (e.g. "HazelnutSpread")
+     * @param accountId - Epic account ID to center the leaderboard around
+     * @param options - Query options
+     */
+    getGameLeaderboard(gameId: string, accountId: string, options?: {
+        fromIndex?: number;
+        findTeams?: boolean;
+    }): Promise<any>;
 }

package/dist/resources/profiles.js

@@ -6,18 +6,66 @@ class ProfilesResource {
         this.client = client;
     }
     /**
-     * Get profile progress (track progress, levels) by display name
-     * @param displayName - Epic Games display name
+     * Get raw Habanero track progress for a single account. Public — no token required.
+     * @param accountId - Epic account ID
+     */
+    async getProgress(accountId) {
+        return this.client.request(`/profile/progress?accountId=${encodeURIComponent(accountId)}`);
+    }
+    /**
+     * Get a player's XP, level, accountLevel, and battle pass tier.
+     * Parsed from QueryProfile (profileId=athena) on the MCP service.
+     * Requires the player's own Fortnite OAuth token — cannot be used for other accounts.
+     * @param accountId - Epic account ID
+     * @param fortniteToken - User's Fortnite OAuth token (required)
      */
-    async getProgress(displayName) {
-        return this.client.request(`/profile/progress?displayName=${encodeURIComponent(displayName)}`);
+    async getLevel(accountId, fortniteToken) {
+        return this.client.request(`/profile/level?accountId=${encodeURIComponent(accountId)}`, { headers: { "x-fortnite-token": fortniteToken } });
     }
     /**
-     * Get enriched ranked progress by display name (human-readable ranks, game modes, season dates)
+     * Get enriched ranked progress — human-readable rank names, game mode labels, season dates.
      * @param displayName - Epic Games display name
      */
     async getRanked(displayName) {
         return this.client.request(`/profile/ranked?displayName=${encodeURIComponent(displayName)}`);
     }
+    /**
+     * Get all available ranked game mode tracks — modes, division counts, and season dates.
+     * @param options - Optional filters
+     */
+    async getTracks(options) {
+        const params = new URLSearchParams();
+        if (options?.endsBefore)
+            params.append("endsBefore", options.endsBefore);
+        if (options?.endsAfter)
+            params.append("endsAfter", options.endsAfter);
+        const qs = params.toString();
+        return this.client.request(`/profile/tracks${qs ? `?${qs}` : ""}`);
+    }
+    /**
+     * Get ranked track progress for multiple account IDs in one request (L3AGUE bulk endpoint).
+     * @param accountIds - Array of Epic account IDs
+     */
+    async getBulkTrackProgress(accountIds) {
+        return this.client.request("/profile/trackprogress/bulk", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(accountIds),
+        });
+    }
+    /**
+     * Get a Habanero game leaderboard centered around an account.
+     * @param gameId - Habanero game identifier (e.g. "HazelnutSpread")
+     * @param accountId - Epic account ID to center the leaderboard around
+     * @param options - Query options
+     */
+    async getGameLeaderboard(gameId, accountId, options) {
+        const params = new URLSearchParams({ accountId });
+        if (options?.fromIndex != null)
+            params.append("fromIndex", String(options.fromIndex));
+        if (options?.findTeams != null)
+            params.append("findTeams", String(options.findTeams));
+        return this.client.request(`/profile/leaderboard/${encodeURIComponent(gameId)}?${params.toString()}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: "{}" });
+    }
 }
 exports.ProfilesResource = ProfilesResource;

package/dist/resources/stats.d.ts

@@ -15,8 +15,10 @@ export declare class StatsResource {
      * @returns Player statistics
      */
     getPlayerStats(accountId: string, options?: {
-        startDate?: string;
-        endDate?: string;
+        /** Unix timestamp (e.g. 1773900001). NOT an ISO date string. */
+        startTime?: string | number;
+        /** Unix timestamp (e.g. 1782950340). NOT an ISO date string. */
+        endTime?: string | number;
         stats?: string[];
     }, fortniteToken?: string): Promise<PlayerStats>;
     /**

package/dist/resources/stats.js

@@ -22,10 +22,10 @@ class StatsResource {
             headers["x-fortnite-token"] = fortniteToken;
         }
         const queryParams = new URLSearchParams();
-        if (options?.startDate)
-            queryParams.append("startDate", options.startDate);
-        if (options?.endDate)
-            queryParams.append("endDate", options.endDate);
+        if (options?.startTime)
+            queryParams.append("startTime", String(options.startTime));
+        if (options?.endTime)
+            queryParams.append("endTime", String(options.endTime));
         if (options?.stats)
             queryParams.append("stats", options.stats.join(","));
         const query = queryParams.toString();

package/dist/resources/tournaments.d.ts

@@ -1,5 +1,5 @@
 import { FortniteAPI } from "../client";
-import { Leaderboard, TournamentTrackerResponse, TournamentEligibilityResponse } from "../types";
+import { Leaderboard, TournamentTrackerResponse, TournamentEligibilityResponse, EventTokenEligibilityResponse } from "../types";
 export declare class TournamentsResource {
     private client;
     constructor(client: FortniteAPI);
@@ -81,6 +81,25 @@ export declare class TournamentsResource {
         days?: number;
         requiredTournaments?: number;
     }): Promise<TournamentEligibilityResponse>;
+    /**
+     * Check a player's token eligibility for a specific event window.
+     *
+     * Verifies all token requirements (requireAllTokens, requireAnyTokens,
+     * requireNoneTokensCaller, etc.) using the Epic tokens endpoint — no player
+     * auth needed. Hardware/system requirements and MFA are always listed as
+     * unverified since they cannot be checked remotely.
+     *
+     * Accepts a display name or an Epic account ID (with or without dashes).
+     *
+     * @param identifier - Player display name or Epic account ID
+     * @param eventId - Epic event ID (e.g. `"epicgames_S40_FNCSMajor1_LCQ_EU"`)
+     * @param options.eventWindowId - Optional window ID; defaults to the most relevant window (live → upcoming → latest ended)
+     * @param options.fortniteToken - Optional user Fortnite token for future extended checks
+     */
+    checkEventEligibility(identifier: string, eventId: string, options?: {
+        eventWindowId?: string;
+        fortniteToken?: string;
+    }): Promise<EventTokenEligibilityResponse>;
     /**
      * Get tournament leaderboard using V2 endpoint (POST with teams body)
      *

package/dist/resources/tournaments.js

@@ -128,6 +128,33 @@ class TournamentsResource {
             },
         });
     }
+    /**
+     * Check a player's token eligibility for a specific event window.
+     *
+     * Verifies all token requirements (requireAllTokens, requireAnyTokens,
+     * requireNoneTokensCaller, etc.) using the Epic tokens endpoint — no player
+     * auth needed. Hardware/system requirements and MFA are always listed as
+     * unverified since they cannot be checked remotely.
+     *
+     * Accepts a display name or an Epic account ID (with or without dashes).
+     *
+     * @param identifier - Player display name or Epic account ID
+     * @param eventId - Epic event ID (e.g. `"epicgames_S40_FNCSMajor1_LCQ_EU"`)
+     * @param options.eventWindowId - Optional window ID; defaults to the most relevant window (live → upcoming → latest ended)
+     * @param options.fortniteToken - Optional user Fortnite token for future extended checks
+     */
+    async checkEventEligibility(identifier, eventId, options) {
+        const query = new URLSearchParams();
+        if (options?.eventWindowId) {
+            query.append("eventWindowId", options.eventWindowId);
+        }
+        const qs = query.toString();
+        const path = `/events/tracker/eligibility/${encodeURIComponent(identifier)}/${encodeURIComponent(eventId)}${qs ? `?${qs}` : ""}`;
+        const requestOptions = options?.fortniteToken
+            ? { headers: { "x-fortnite-token": options.fortniteToken } }
+            : undefined;
+        return this.client.request(path, requestOptions);
+    }
     /**
      * Get tournament leaderboard using V2 endpoint (POST with teams body)
      *

package/dist/types/index.d.ts

@@ -214,6 +214,36 @@ export interface TournamentEligibilityResponse {
     newest_tournament_date: string | null;
     recent_tournaments: TournamentTrackerEntry[];
 }
+export type TokenRequirementType = "mustHave" | "mustHaveAny" | "mustNotHave";
+export type TokenGroupType = "requireAllTokens" | "requireAnyTokens" | "requireNoneTokensCaller" | "requireAllTokensCaller" | "requireAnyTokensCaller";
+export interface VerifiedRequirement {
+    token: string;
+    label: string;
+    type: TokenRequirementType;
+    tokenGroup: TokenGroupType;
+    met: boolean;
+}
+export interface UnverifiedRequirement {
+    type: "accountLevel" | "systemFeature" | "mfa";
+    key: string;
+    label: string;
+    description: string;
+    /** Only present for accountLevel requirements */
+    threshold?: number;
+    /** Only present for accountLevel requirements */
+    estimatedCurrentLevel?: number | null;
+    /** Only present for accountLevel requirements */
+    estimatedMet?: boolean | null;
+}
+export interface EventTokenEligibilityResponse {
+    accountId: string;
+    displayName: string;
+    eventId: string;
+    eventWindowId: string;
+    isEligible: boolean;
+    verifiedRequirements: VerifiedRequirement[];
+    unverifiedRequirements: UnverifiedRequirement[];
+}
 export interface SeasonEntry {
     chapter: number;
     season: number;
@@ -454,6 +484,47 @@ export interface SuggestedFriend {
     displayName?: string;
     mutualFriends?: number;
 }
+export interface ProfileLevel {
+    accountId: string;
+    /** Current season level */
+    level: number | null;
+    /** Current season XP */
+    xp: number | null;
+    /** Cumulative lifetime account level across all seasons — used for eligibility requirements */
+    accountLevel: number | null;
+    battlePass: {
+        tier: number | null;
+        xp: number | null;
+        purchased: boolean;
+    };
+}
+export interface RankedProgress {
+    trackguid: string;
+    rankingType: string | null;
+    gameMode: string;
+    seasonId: string | null;
+    seasonBegin: string | null;
+    seasonEnd: string | null;
+    isCurrent: boolean;
+    currentDivision: number;
+    currentRank: string;
+    highestDivision: number;
+    highestRank: string;
+    rankProgress: number | null;
+    unrealRank: number | null;
+}
+export interface TrackDefinition {
+    trackguid: string;
+    trackId: string;
+    rankingType: string;
+    divisionCount: number;
+    beginTime: string | null;
+    endTime: string | null;
+    [key: string]: any;
+}
+export interface PlayerTokensResponse {
+    [accountId: string]: string[];
+}
 export interface PlayerStats {
     accountId: string;
     stats: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yaelouuu/fortnite-api",
-  "version": "6.1.0",
-  "description": "SDK for Fortnite Tournaments API by Royal Arena - Author : Yael Brinkert",
+  "version": "7.0.0",
+  "description": "SDK for Fortnite API - api-fortnite.com - Author : Yael Brinkert",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {