@yaelouuu/fortnite-api 4.1.0 → 4.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Fortnite API SDK
 
-JavaScript/TypeScript SDK for the Fortnite API by Royal Arena.
+Official JavaScript/TypeScript SDK for the Fortnite API by Royal Arena.
 
 ## Installation
 
@@ -10,7 +10,7 @@ npm install @yaelouuu/fortnite-api
 
 ## API Key
 
-Acquire your API Key by creating a Free Account here : https://api-fortnite.com
+Acquire your API Key by creating a Free Account here: https://api-fortnite.com
 
 ## Quick Start
 
@@ -26,27 +26,502 @@ const shop = await client.shop.getCurrent();
 
 // Get tournament leaderboard
 const leaderboard = await client.tournaments.getLeaderboard({
-  eventId: "epicgames_...",
-  eventWindowId: "S37_...",
+  eventId: "epicgames_S37_BlitzCupsAllPlatforms_BR",
+  eventWindowId: "S37_BlitzCupsAllPlatforms_Event1_BR",
   page: 0,
 });
+```
+
+## Features
+
+- ✅ Full TypeScript support with comprehensive type definitions
+- ✅ Promise-based async/await API
+- ✅ Automatic error handling with detailed error messages
+- ✅ Support for all Fortnite API endpoints
+- ✅ Built-in OAuth flow helpers
+- ✅ Tree-shakeable for optimal bundle size
+
+---
+
+## 📚 API Resources
+
+### Shop
+
+Access the Fortnite Item Shop and Battle Pass data.
+
+```typescript
+// Get current item shop
+const shop = await client.shop.getCurrent();
+
+// Get current Battle Pass
+const battlePass = await client.battlepass.getBattlePass();
+```
+
+---
+
+### Tournaments
+
+Comprehensive tournament data including leaderboards, events, and eligibility tracking.
+
+#### Get Current Events
+```typescript
+const events = await client.tournaments.getCurrent();
+```
+
+#### Get Tournament Leaderboard (V1)
+```typescript
+const leaderboard = await client.tournaments.getLeaderboard({
+  eventId: "epicgames_S37_BlitzCupsAllPlatforms_BR",
+  eventWindowId: "S37_BlitzCupsAllPlatforms_Event1_BR",
+  page: 0,
+});
+```
+
+#### Get Tournament Leaderboard (V2) - **NEW**
+Enhanced leaderboard endpoint with POST body for bulk team queries:
+
+```typescript
+// Solo tournament - query multiple players
+const leaderboard = await client.tournaments.getLeaderboardV2(
+  {
+    eventId: "epicgames_S37_BlitzCupsAllPlatforms_BR",
+    eventWindowId: "S37_BlitzCupsAllPlatforms_Event1_BR",
+  },
+  [
+    ["accountId1"],
+    ["accountId2"],
+    ["accountId3"],
+  ]
+);
+
+// Duo tournament
+const duoLeaderboard = await client.tournaments.getLeaderboardV2(
+  {
+    eventId: "epicgames_S37_DuoCup_BR",
+    eventWindowId: "S37_DuoCup_Event1_BR",
+  },
+  [
+    ["player1Id", "player2Id"],
+    ["player3Id", "player4Id"],
+  ]
+);
+```
+
+#### Tournament Tracker
+Track player participation history:
+
+```typescript
+const tracker = await client.tournaments.getTracker(
+  "accountId",
+  "fortniteToken"
+);
+// Returns: All tournaments the player has participated in
+```
+
+#### Check Tournament Eligibility
+Verify if a player meets requirements for major tournaments (e.g., 14 tournaments in 180 days):
+
+```typescript
+const eligibility = await client.tournaments.checkEligibility(
+  "accountId",
+  "fortniteToken",
+  {
+    days: 180,
+    requiredTournaments: 14,
+  }
+);
+
+console.log(eligibility.eligible); // true/false
+console.log(eligibility.tournaments_remaining); // How many more needed
+```
+
+#### Download Events
+Get personalized event data:
+
+```typescript
+const events = await client.tournaments.download(
+  {
+    accountId: "your-account-id",
+    region: "EU",
+    platform: "Windows",
+  },
+  "fortniteToken"
+);
+```
+
+---
+
+### Quests - **NEW**
 
-// Get profile stats
-const stats = await client.profiles.getStats("PlayerName");
+Access player quest progress, XP, and account level information.
 
-// Get season info
+```typescript
+// Get quest data for an account
+const quests = await client.quests.getQuests(
+  "accountId",
+  "fortniteToken"
+);
+
+// Returns comprehensive data:
+// - Active quest progress
+// - Account XP and level
+// - Playtime statistics
+// - Quest rewards
+```
+
+**Authentication Required**: User's personal Fortnite OAuth token
+
+---
+
+### Profiles
+
+Player profile information and statistics.
+
+```typescript
+// Get profile by display name
+const profile = await client.profiles.getByName("PlayerName");
+
+// Get profile statistics
+const stats = await client.profiles.getStats("accountId");
+```
+
+---
+
+### Calendar
+
+Fortnite in-game calendar and season information.
+
+```typescript
+// Get current season info
 const season = await client.calendar.getCurrentSeason();
+
+// Returns: Season number, start/end dates, and more
 ```
 
-## Features
+---
 
-- ✅ Full TypeScript support
-- ✅ Promise-based async/await API
-- ✅ Automatic error handling
-- ✅ Built-in retry logic (optional)
-- ✅ Tree-shakeable
+### Bundles
+
+Fortnite game asset bundles and cosmetics.
+
+```typescript
+// Get all available bundles
+const bundles = await client.bundles.getAll();
+```
+
+---
+
+### Weapons
+
+Comprehensive weapon data including stats and metadata.
+
+```typescript
+// Get all weapons
+const weapons = await client.weapons.getAll();
+
+// Includes: Damage, fire rate, reload time, rarity, and more
+```
+
+---
+
+### OAuth
+
+OAuth authentication flow helpers for obtaining user tokens.
+
+```typescript
+// Start OAuth flow
+const flow = await client.oauth.startFlow();
+console.log(flow.verificationUri); // Show this URL to the user
+
+// Complete OAuth flow
+const authData = await client.oauth.completeFlow(flow.flowId);
+console.log(authData.accessToken); // User's Fortnite token
+console.log(authData.deviceAuth); // Device auth credentials
+
+// Refresh token
+const refreshed = await client.oauth.refreshToken(authData.refreshToken);
+```
+
+---
+
+### Parsing
+
+Parse Fortnite replay files to extract match data.
+
+```typescript
+// Parse a single replay file
+const replayData = await client.parsing.parseReplay(fileBuffer);
+
+// Parse multiple replays
+const batchResults = await client.parsing.parseBatch([file1, file2, file3]);
+```
+
+---
+
+### Account - **NEW**
+
+Comprehensive account lookup and management with cross-platform support.
+
+#### Lookup by Account ID
+```typescript
+const account = await client.account.getById('accountId123');
+// Returns: { id, displayName, externalAuths }
+```
+
+#### Lookup by Display Name
+```typescript
+const account = await client.account.getByDisplayName('Ninja');
+// Returns: Epic account information
+```
+
+#### Cross-Platform Lookup
+Search for accounts by platform usernames (PSN, Xbox, Steam, Nintendo, Twitch, GitHub):
+
+```typescript
+// Find by PSN username
+const account = await client.account.getByExternalDisplayName(
+  'psn',
+  'PSN_Username',
+  true  // case insensitive
+);
+
+// Find by Xbox gamertag
+const xboxAccount = await client.account.getByExternalDisplayName(
+  'xbl',
+  'Xbox_Gamertag',
+  false  // case sensitive
+);
+```
+
+**Supported Platforms:**
+- `psn` - PlayStation Network
+- `xbl` - Xbox Live
+- `steam` - Steam
+- `nintendo` - Nintendo Switch
+- `twitch` - Twitch
+- `github` - GitHub
+
+#### Bulk Operations
+Process multiple accounts efficiently:
+
+```typescript
+// Bulk account lookup (max 100)
+const accounts = await client.account.getBulk([
+  'accountId1',
+  'accountId2',
+  'accountId3'
+]);
+
+// Bulk external display name lookup
+const accounts = await client.account.getBulkExternalDisplayNames({
+  lookups: [
+    { externalAuthType: 'psn', displayName: 'PSNUser1' },
+    { externalAuthType: 'xbl', displayName: 'XboxUser1' },
+    { externalAuthType: 'steam', displayName: 'SteamUser1' }
+  ]
+});
+
+// Bulk external ID lookup
+const accounts = await client.account.getBulkExternalIds({
+  lookups: [
+    { externalAuthType: 'psn', externalId: 'psn-id-123' },
+    { externalAuthType: 'xbl', externalId: 'xbl-id-456' }
+  ]
+});
+```
+
+#### External Authentications
+Get platform connection information:
+
+```typescript
+// List all linked platforms
+const auths = await client.account.getExternalAuths('accountId123');
+// Returns: Array of all connected platforms
+
+// Get specific platform connection
+const psnAuth = await client.account.getExternalAuth('accountId123', 'psn');
+// Returns: PSN-specific connection details
+```
+
+---
+
+### FN (Fortnite Game) - **NEW**
+
+Fortnite-specific game data including inventory, features, and settings.
+
+#### Battle Royale Inventory
+Get player V-Bucks and in-game currency:
+
+```typescript
+const inventory = await client.fn.getBRInventory('accountId123');
+// Returns: { stash: { globalcash: 1250 } }
+console.log(`Player has ${inventory.stash.globalcash} V-Bucks`);
+```
+
+#### Storefront Keychain
+Get encryption keys for storefront data:
+
+```typescript
+const keychain = await client.fn.getKeychain();
+// Returns: Storefront encryption keychain
+```
+
+#### Purchase Receipts
+Get player purchase history:
+
+```typescript
+const receipts = await client.fn.getReceipts('accountId123');
+// Returns: Array of purchase receipts
+```
+
+#### Enabled Features
+Get currently active game features:
+
+```typescript
+const features = await client.fn.getEnabledFeatures();
+// Returns: Currently enabled game features
+```
+
+#### Version Check
+Validate game client version:
+
+```typescript
+const versionCheck = await client.fn.checkVersion(
+  'Windows',
+  '++Fortnite+Release-30.40-CL-35235494-Windows'
+);
+// Returns: { type: 'NO_UPDATE' } or update information
+```
+
+#### Privacy Settings (Requires User Token)
+Manage player privacy settings:
+
+```typescript
+// Get privacy settings
+const privacy = await client.fn.getPrivacySettings(
+  'accountId123',
+  'fortniteToken'
+);
+
+// Update privacy settings
+await client.fn.updatePrivacySettings(
+  'accountId123',
+  {
+    optOutOfPublicLeaderboards: true
+  },
+  'fortniteToken'
+);
+```
+
+#### Entitlement (Requires User Token)
+Check and request Fortnite access:
+
+```typescript
+// Check if user has Fortnite access
+const check = await client.fn.checkEntitlement('fortniteToken');
+
+// Request Fortnite access
+await client.fn.requestEntitlement('accountId123', 'fortniteToken');
+```
+
+---
+
+## 🔐 Authentication
+
+Some endpoints require user-specific authentication:
+
+### Endpoints Requiring User Token:
+- `client.quests.getQuests()`
+- `client.tournaments.getTracker()`
+- `client.tournaments.checkEligibility()`
+- `client.tournaments.download()`
+- `client.fn.getPrivacySettings()`
+- `client.fn.updatePrivacySettings()`
+- `client.fn.checkEntitlement()`
+- `client.fn.requestEntitlement()`
+
+**How to obtain user tokens:**
+
+1. Use the OAuth flow:
+```typescript
+const flow = await client.oauth.startFlow();
+// Direct user to flow.verificationUri
+const auth = await client.oauth.completeFlow(flow.flowId);
+// Use auth.accessToken as the fortniteToken parameter
+```
+
+---
+
+## 🚀 Advanced Usage
+
+### Custom Base URL
+
+```typescript
+const client = new FortniteAPI({
+  apiKey: "your-api-key",
+  baseUrl: "https://custom-api-url.com/api",
+});
+```
+
+### Error Handling
+
+```typescript
+import { FortniteAPIError } from "@yaelouuu/fortnite-api";
+
+try {
+  const shop = await client.shop.getCurrent();
+} catch (error) {
+  if (error instanceof FortniteAPIError) {
+    console.error(`API Error: ${error.message}`);
+    console.error(`Status Code: ${error.statusCode}`);
+    console.error(`Details:`, error.data);
+  }
+}
+```
+
+---
+
+## 📖 Documentation
+
+- **Full API Documentation (Swagger)**: https://documentation.api-fortnite.com/documentation
+- **SDK Documentation**: https://sdk.api-fortnite.com/
+- **Support**: https://api-fortnite.com
+
+---
+
+## 📝 License
+
+MIT
+
+---
+
+## 🆕 Changelog
+
+### v4.2.0 (2026-01-06)
+- ✨ **NEW** `AccountResource` with 8 methods:
+  - Account lookups by ID, display name, and external platforms
+  - Cross-platform search (PSN, Xbox, Steam, Nintendo, Twitch, GitHub)
+  - Bulk operations (up to 100 accounts)
+  - External authentication management
+- ✨ **NEW** `FNResource` with 9 methods:
+  - BR inventory (V-Bucks)
+  - Storefront keychain
+  - Purchase receipts
+  - Enabled features
+  - Version checking
+  - Privacy settings management
+  - Entitlement checking
+- 📝 Comprehensive TypeScript types for all new endpoints
+- 🎯 Full JSDoc documentation
+- ✅ 100% backward compatible
 
-## Documentation
+### v4.1.0
+- ✨ Added `WeaponsResource` with weapon stats and metadata
+- 🐛 Various bug fixes and improvements
 
-Full API documentation (swagger): https://documentation.api-fortnite.com/documentation
-SDK documentation: https://sdk.api-fortnite.com/
+### v4.0.0
+- ✨ Added `QuestsResource` with `getQuests()` method
+- ✨ Added `getLeaderboardV2()` method to `TournamentsResource`
+- 🐛 Fixed typo in `battlepass` property name
+- 📝 Comprehensive JSDoc documentation for all resources
+- 🎯 Full TypeScript type coverage

package/dist/client.d.ts

@@ -8,6 +8,8 @@ import { ParsingResource } from "./resources/parsing";
 import { WeaponsResource } from "./resources/weapons";
 import { BattlePassResource } from "./resources/battlepass";
 import { QuestsResource } from "./resources/quests";
+import { AccountResource } from "./resources/account";
+import { FNResource } from "./resources/fn";
 export interface ClientOptions {
     apiKey: string;
     baseUrl?: string;
@@ -25,6 +27,8 @@ export declare class FortniteAPI {
     weapons: WeaponsResource;
     battlepass: BattlePassResource;
     quests: QuestsResource;
+    account: AccountResource;
+    fn: FNResource;
     constructor(options: ClientOptions);
     /**
      * Internal method to make HTTP requests

package/dist/client.js

@@ -12,6 +12,8 @@ const parsing_1 = require("./resources/parsing");
 const weapons_1 = require("./resources/weapons");
 const battlepass_1 = require("./resources/battlepass");
 const quests_1 = require("./resources/quests");
+const account_1 = require("./resources/account");
+const fn_1 = require("./resources/fn");
 class FortniteAPI {
     constructor(options) {
         this.apiKey = options.apiKey;
@@ -28,6 +30,8 @@ class FortniteAPI {
         this.weapons = new weapons_1.WeaponsResource(this);
         this.battlepass = new battlepass_1.BattlePassResource(this);
         this.quests = new quests_1.QuestsResource(this);
+        this.account = new account_1.AccountResource(this);
+        this.fn = new fn_1.FNResource(this);
     }
     /**
      * Internal method to make HTTP requests

package/dist/resources/account.d.ts

@@ -0,0 +1,54 @@
+import { FortniteAPI } from "../client";
+import { Account, ExternalAuth, BulkExternalDisplayNameRequest, BulkExternalIdRequest } from "../types";
+export declare class AccountResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Lookup account by Account ID
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getById(accountId: string, fortniteToken?: string): Promise<Account>;
+    /**
+     * Bulk account lookup by Account IDs
+     * @param accountIds - Array of Epic Games account IDs (max 100)
+     */
+    getBulk(accountIds: string[]): Promise<Account[]>;
+    /**
+     * Lookup account by Epic display name
+     * @param displayName - Epic Games display name
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getByDisplayName(displayName: string, fortniteToken?: string): Promise<Account>;
+    /**
+     * Cross-platform account lookup by external display name
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param displayName - Platform display name
+     * @param caseInsensitive - Case-insensitive search (default: false)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getByExternalDisplayName(platform: string, displayName: string, caseInsensitive?: boolean, fortniteToken?: string): Promise<Account>;
+    /**
+     * Bulk external display name lookup
+     * @param payload - Array of platform/displayName pairs (max 100)
+     */
+    getBulkExternalDisplayNames(payload: BulkExternalDisplayNameRequest): Promise<Account[]>;
+    /**
+     * Bulk external ID lookup
+     * @param payload - Array of platform/externalId pairs (max 100)
+     */
+    getBulkExternalIds(payload: BulkExternalIdRequest): Promise<Account[]>;
+    /**
+     * Get all external authentications for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getExternalAuths(accountId: string, fortniteToken?: string): Promise<ExternalAuth[]>;
+    /**
+     * Get specific external authentication for an account
+     * @param accountId - Epic Games account ID
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getExternalAuth(accountId: string, platform: string, fortniteToken?: string): Promise<ExternalAuth>;
+}

package/dist/resources/account.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountResource = void 0;
+class AccountResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Lookup account by Account ID
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getById(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}`, { headers }, "v1");
+    }
+    /**
+     * Bulk account lookup by Account IDs
+     * @param accountIds - Array of Epic Games account IDs (max 100)
+     */
+    async getBulk(accountIds) {
+        const queryString = accountIds
+            .map((id) => `accountId=${encodeURIComponent(id)}`)
+            .join("&");
+        return this.client.request(`/account/bulk?${queryString}`, {}, "v1");
+    }
+    /**
+     * Lookup account by Epic display name
+     * @param displayName - Epic Games display name
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getByDisplayName(displayName, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/displayName/${encodeURIComponent(displayName)}`, { headers }, "v1");
+    }
+    /**
+     * Cross-platform account lookup by external display name
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param displayName - Platform display name
+     * @param caseInsensitive - Case-insensitive search (default: false)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getByExternalDisplayName(platform, displayName, caseInsensitive = false, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const query = caseInsensitive ? "?caseInsensitive=true" : "";
+        return this.client.request(`/account/external/${platform}/displayName/${encodeURIComponent(displayName)}${query}`, { headers }, "v1");
+    }
+    /**
+     * Bulk external display name lookup
+     * @param payload - Array of platform/displayName pairs (max 100)
+     */
+    async getBulkExternalDisplayNames(payload) {
+        return this.client.request(`/account/external/displayNames/bulk`, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, "v1");
+    }
+    /**
+     * Bulk external ID lookup
+     * @param payload - Array of platform/externalId pairs (max 100)
+     */
+    async getBulkExternalIds(payload) {
+        return this.client.request(`/account/external/ids/bulk`, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, "v1");
+    }
+    /**
+     * Get all external authentications for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getExternalAuths(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}/externalAuths`, { headers }, "v1");
+    }
+    /**
+     * Get specific external authentication for an account
+     * @param accountId - Epic Games account ID
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getExternalAuth(accountId, platform, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}/externalAuths/${platform}`, { headers }, "v1");
+    }
+}
+exports.AccountResource = AccountResource;

package/dist/resources/fn.d.ts

@@ -0,0 +1,56 @@
+import { FortniteAPI } from "../client";
+import { BRInventory, Keychain, Receipt, EnabledFeatures, VersionCheck, PrivacySettings, EntitlementCheck } from "../types";
+export declare class FNResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get Battle Royale inventory (V-Bucks and currency)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getBRInventory(accountId: string, fortniteToken?: string): Promise<BRInventory>;
+    /**
+     * Get storefront encryption keychain
+     */
+    getKeychain(): Promise<Keychain>;
+    /**
+     * Get purchase receipts for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getReceipts(accountId: string, fortniteToken?: string): Promise<Receipt[]>;
+    /**
+     * Get currently enabled game features
+     */
+    getEnabledFeatures(): Promise<EnabledFeatures>;
+    /**
+     * Check game version
+     * @param platform - Platform name (Windows, Mac, etc.)
+     * @param version - Version string to check
+     */
+    checkVersion(platform: string, version: string): Promise<VersionCheck>;
+    /**
+     * Get privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    getPrivacySettings(accountId: string, fortniteToken: string): Promise<PrivacySettings>;
+    /**
+     * Update privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param settings - Privacy settings to update
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    updatePrivacySettings(accountId: string, settings: Partial<PrivacySettings>, fortniteToken: string): Promise<PrivacySettings>;
+    /**
+     * Check Fortnite entitlement (requires user token)
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    checkEntitlement(fortniteToken: string): Promise<EntitlementCheck>;
+    /**
+     * Request Fortnite entitlement access (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    requestEntitlement(accountId: string, fortniteToken: string): Promise<void>;
+}

package/dist/resources/fn.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FNResource = void 0;
+class FNResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get Battle Royale inventory (V-Bucks and currency)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getBRInventory(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/fn/br-inventory/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get storefront encryption keychain
+     */
+    async getKeychain() {
+        return this.client.request("/fn/keychain", {}, "v2");
+    }
+    /**
+     * Get purchase receipts for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getReceipts(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/fn/receipts/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get currently enabled game features
+     */
+    async getEnabledFeatures() {
+        return this.client.request("/fn/enabled-features", {}, "v2");
+    }
+    /**
+     * Check game version
+     * @param platform - Platform name (Windows, Mac, etc.)
+     * @param version - Version string to check
+     */
+    async checkVersion(platform, version) {
+        return this.client.request(`/fn/version/${platform}?version=${encodeURIComponent(version)}`, {}, "v2");
+    }
+    /**
+     * Get privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async getPrivacySettings(accountId, fortniteToken) {
+        return this.client.request(`/fn/privacy/${accountId}`, {
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+    /**
+     * Update privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param settings - Privacy settings to update
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async updatePrivacySettings(accountId, settings, fortniteToken) {
+        return this.client.request(`/fn/privacy/${accountId}`, {
+            method: "POST",
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+            body: JSON.stringify(settings),
+        }, "v2");
+    }
+    /**
+     * Check Fortnite entitlement (requires user token)
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async checkEntitlement(fortniteToken) {
+        return this.client.request("/fn/entitlement", {
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+    /**
+     * Request Fortnite entitlement access (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async requestEntitlement(accountId, fortniteToken) {
+        await this.client.request(`/fn/entitlement/${accountId}`, {
+            method: "POST",
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+}
+exports.FNResource = FNResource;

package/dist/resources/quests.d.ts

@@ -1,14 +1,53 @@
 import { FortniteAPI } from "../client";
 import { QuestsResponse } from "../types";
+/**
+ * QuestsResource provides access to Fortnite quests and account progression data
+ *
+ * This resource allows you to fetch player quest progress, XP, playtime, and account level.
+ * All methods require the user's personal Fortnite OAuth token obtained through the OAuth flow.
+ *
+ * @example
+ * ```typescript
+ * // Get quests for an account
+ * const quests = await client.quests.getQuests(
+ *   "account-id-here",
+ *   "user-fortnite-token-here"
+ * );
+ * ```
+ */
 export declare class QuestsResource {
     private client;
     constructor(client: FortniteAPI);
     /**
      * Get account quests and level information
-     * Requires user's own Fortnite token
-     * @param accountId - Epic Games Account ID
-     * @param fortniteToken - User's Fortnite access token (from OAuth flow)
-     * @returns Quest progress, XP, playtime, and account level data
+     *
+     * Retrieves comprehensive quest data including:
+     * - Active quest progress and completion status
+     * - Account XP and level information
+     * - Total playtime statistics
+     * - Quest rewards and milestones
+     *
+     * **Authentication**: Requires user's personal Fortnite OAuth token
+     *
+     * **API Version**: v3
+     *
+     * **Rate Limit**: Standard API rate limits apply
+     *
+     * @param accountId - Epic Games Account ID (32 character hexadecimal string)
+     * @param fortniteToken - User's Fortnite access token obtained from OAuth flow
+     *
+     * @returns Promise resolving to quest progress, XP, playtime, and account level data
+     *
+     * @throws {FortniteAPIError} When the request fails (invalid token, account not found, etc.)
+     *
+     * @example
+     * ```typescript
+     * const accountId = "a1b2c3d4e5f6..."; // 32 character account ID
+     * const token = "eg1~..."; // User's Fortnite OAuth token
+     *
+     * const questData = await client.quests.getQuests(accountId, token);
+     * console.log(questData);
+     * ```
      */
     getQuests(accountId: string, fortniteToken: string): Promise<QuestsResponse>;
 }

package/dist/resources/quests.js

@@ -1,16 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuestsResource = void 0;
+/**
+ * QuestsResource provides access to Fortnite quests and account progression data
+ *
+ * This resource allows you to fetch player quest progress, XP, playtime, and account level.
+ * All methods require the user's personal Fortnite OAuth token obtained through the OAuth flow.
+ *
+ * @example
+ * ```typescript
+ * // Get quests for an account
+ * const quests = await client.quests.getQuests(
+ *   "account-id-here",
+ *   "user-fortnite-token-here"
+ * );
+ * ```
+ */
 class QuestsResource {
     constructor(client) {
         this.client = client;
     }
     /**
      * Get account quests and level information
-     * Requires user's own Fortnite token
-     * @param accountId - Epic Games Account ID
-     * @param fortniteToken - User's Fortnite access token (from OAuth flow)
-     * @returns Quest progress, XP, playtime, and account level data
+     *
+     * Retrieves comprehensive quest data including:
+     * - Active quest progress and completion status
+     * - Account XP and level information
+     * - Total playtime statistics
+     * - Quest rewards and milestones
+     *
+     * **Authentication**: Requires user's personal Fortnite OAuth token
+     *
+     * **API Version**: v3
+     *
+     * **Rate Limit**: Standard API rate limits apply
+     *
+     * @param accountId - Epic Games Account ID (32 character hexadecimal string)
+     * @param fortniteToken - User's Fortnite access token obtained from OAuth flow
+     *
+     * @returns Promise resolving to quest progress, XP, playtime, and account level data
+     *
+     * @throws {FortniteAPIError} When the request fails (invalid token, account not found, etc.)
+     *
+     * @example
+     * ```typescript
+     * const accountId = "a1b2c3d4e5f6..."; // 32 character account ID
+     * const token = "eg1~..."; // User's Fortnite OAuth token
+     *
+     * const questData = await client.quests.getQuests(accountId, token);
+     * console.log(questData);
+     * ```
      */
     async getQuests(accountId, fortniteToken) {
         return this.client.request(`/quests/${accountId}`, {

package/dist/resources/tournaments.d.ts

@@ -68,11 +68,73 @@ export declare class TournamentsResource {
     }): Promise<TournamentEligibilityResponse>;
     /**
      * Get tournament leaderboard using V2 endpoint (POST with teams body)
-     * @param params.eventId - Event ID
-     * @param params.eventWindowId - Event window ID
-     * @param params.leaderboardDef - Optional leaderboard definition (required for Ranked Cups)
-     * @param teams - Array of team member account ID arrays (e.g., [["accountId1"], ["accountId2"]])
-     * @param fortniteToken - Optional user's Fortnite token for personalized view
+     *
+     * This is an enhanced version of the leaderboard endpoint that accepts a POST request
+     * with a teams array in the body. Use this endpoint when you need to query leaderboard
+     * data for multiple teams at once or for Ranked Cups that require specific team lookups.
+     *
+     * **Differences from V1**:
+     * - Uses POST method instead of GET
+     * - Accepts teams array in request body
+     * - Better suited for bulk team queries
+     * - Required for certain Ranked Cup leaderboards
+     *
+     * **Authentication**: Optional. Include fortniteToken for personalized leaderboard views
+     *
+     * **API Version**: v2
+     *
+     * **Rate Limit**: Standard API rate limits apply
+     *
+     * @param params - Leaderboard query parameters
+     * @param params.eventId - Event ID (e.g., "epicgames_S37_BlitzCupsAllPlatforms_BR")
+     * @param params.eventWindowId - Event window ID (e.g., "S37_BlitzCupsAllPlatforms_Event1_BR")
+     * @param params.leaderboardDef - Optional leaderboard definition ID (required for Ranked Cups with multiple leaderboards)
+     * @param teams - Array of team member account ID arrays. Each team is an array of account IDs.
+     *                For solo events: [["accountId1"], ["accountId2"]]
+     *                For duo events: [["player1Id", "player2Id"], ["player3Id", "player4Id"]]
+     * @param fortniteToken - Optional user's Fortnite access token for personalized leaderboard view
+     *
+     * @returns Promise resolving to leaderboard data with entries, ranks, and stats
+     *
+     * @throws {FortniteAPIError} When the request fails (invalid event, missing leaderboardDef, etc.)
+     *
+     * @example
+     * ```typescript
+     * // Get leaderboard for multiple solo players
+     * const leaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_BlitzCupsAllPlatforms_BR",
+     *     eventWindowId: "S37_BlitzCupsAllPlatforms_Event1_BR"
+     *   },
+     *   [
+     *     ["accountId1"],
+     *     ["accountId2"],
+     *     ["accountId3"]
+     *   ]
+     * );
+     *
+     * // For duo tournament
+     * const duoLeaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_DuoCup_BR",
+     *     eventWindowId: "S37_DuoCup_Event1_BR"
+     *   },
+     *   [
+     *     ["player1Id", "player2Id"],
+     *     ["player3Id", "player4Id"]
+     *   ]
+     * );
+     *
+     * // For Ranked Cup with leaderboardDef
+     * const rankedLeaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_RankedCup_BR",
+     *     eventWindowId: "S37_RankedCup_Event1_BR",
+     *     leaderboardDef: "ranked_br_division_7"
+     *   },
+     *   [["accountId1"], ["accountId2"]]
+     * );
+     * ```
      */
     getLeaderboardV2(params: {
         eventId: string;

package/dist/resources/tournaments.js

@@ -114,11 +114,73 @@ class TournamentsResource {
     }
     /**
      * Get tournament leaderboard using V2 endpoint (POST with teams body)
-     * @param params.eventId - Event ID
-     * @param params.eventWindowId - Event window ID
-     * @param params.leaderboardDef - Optional leaderboard definition (required for Ranked Cups)
-     * @param teams - Array of team member account ID arrays (e.g., [["accountId1"], ["accountId2"]])
-     * @param fortniteToken - Optional user's Fortnite token for personalized view
+     *
+     * This is an enhanced version of the leaderboard endpoint that accepts a POST request
+     * with a teams array in the body. Use this endpoint when you need to query leaderboard
+     * data for multiple teams at once or for Ranked Cups that require specific team lookups.
+     *
+     * **Differences from V1**:
+     * - Uses POST method instead of GET
+     * - Accepts teams array in request body
+     * - Better suited for bulk team queries
+     * - Required for certain Ranked Cup leaderboards
+     *
+     * **Authentication**: Optional. Include fortniteToken for personalized leaderboard views
+     *
+     * **API Version**: v2
+     *
+     * **Rate Limit**: Standard API rate limits apply
+     *
+     * @param params - Leaderboard query parameters
+     * @param params.eventId - Event ID (e.g., "epicgames_S37_BlitzCupsAllPlatforms_BR")
+     * @param params.eventWindowId - Event window ID (e.g., "S37_BlitzCupsAllPlatforms_Event1_BR")
+     * @param params.leaderboardDef - Optional leaderboard definition ID (required for Ranked Cups with multiple leaderboards)
+     * @param teams - Array of team member account ID arrays. Each team is an array of account IDs.
+     *                For solo events: [["accountId1"], ["accountId2"]]
+     *                For duo events: [["player1Id", "player2Id"], ["player3Id", "player4Id"]]
+     * @param fortniteToken - Optional user's Fortnite access token for personalized leaderboard view
+     *
+     * @returns Promise resolving to leaderboard data with entries, ranks, and stats
+     *
+     * @throws {FortniteAPIError} When the request fails (invalid event, missing leaderboardDef, etc.)
+     *
+     * @example
+     * ```typescript
+     * // Get leaderboard for multiple solo players
+     * const leaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_BlitzCupsAllPlatforms_BR",
+     *     eventWindowId: "S37_BlitzCupsAllPlatforms_Event1_BR"
+     *   },
+     *   [
+     *     ["accountId1"],
+     *     ["accountId2"],
+     *     ["accountId3"]
+     *   ]
+     * );
+     *
+     * // For duo tournament
+     * const duoLeaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_DuoCup_BR",
+     *     eventWindowId: "S37_DuoCup_Event1_BR"
+     *   },
+     *   [
+     *     ["player1Id", "player2Id"],
+     *     ["player3Id", "player4Id"]
+     *   ]
+     * );
+     *
+     * // For Ranked Cup with leaderboardDef
+     * const rankedLeaderboard = await client.tournaments.getLeaderboardV2(
+     *   {
+     *     eventId: "epicgames_S37_RankedCup_BR",
+     *     eventWindowId: "S37_RankedCup_Event1_BR",
+     *     leaderboardDef: "ranked_br_division_7"
+     *   },
+     *   [["accountId1"], ["accountId2"]]
+     * );
+     * ```
      */
     async getLeaderboardV2(params, teams, fortniteToken) {
         const query = new URLSearchParams({

package/dist/types/index.d.ts

@@ -292,3 +292,66 @@ export interface BattlePassOffers {
 export interface QuestsResponse {
     [key: string]: any;
 }
+export interface Account {
+    id: string;
+    displayName: string;
+    externalAuths?: Record<string, ExternalAuth>;
+}
+export interface ExternalAuth {
+    accountId: string;
+    type: string;
+    externalAuthId?: string;
+    externalDisplayName?: string;
+    authIds?: Array<{
+        id: string;
+        type: string;
+    }>;
+}
+export interface BulkExternalDisplayNameRequest {
+    lookups: Array<{
+        externalAuthType: string;
+        displayName: string;
+    }>;
+}
+export interface BulkExternalIdRequest {
+    lookups: Array<{
+        externalAuthType: string;
+        externalId: string;
+    }>;
+}
+export interface BRInventory {
+    stash?: {
+        globalcash?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface Keychain {
+    keychain?: Array<{
+        key: string;
+        [key: string]: any;
+    }>;
+    [key: string]: any;
+}
+export interface Receipt {
+    receiptId: string;
+    purchaseDate: string;
+    offerId: string;
+    [key: string]: any;
+}
+export interface EnabledFeatures {
+    [key: string]: any;
+}
+export interface VersionCheck {
+    type: string;
+    [key: string]: any;
+}
+export interface PrivacySettings {
+    accountId?: string;
+    optOutOfPublicLeaderboards?: boolean;
+    [key: string]: any;
+}
+export interface EntitlementCheck {
+    entitlement?: boolean;
+    [key: string]: any;
+}

package/package.json

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