Note: Authentication is required for all endpoints. Ensure the inclusion of your API Key and Player UID in each request.
| Parameter | Description |
|---|---|
PlayerUid |
The unique identifier assigned to each player. This parameter is case-sensitive and must match the player's record exactly. |
region |
The region code (e.g., NA, EU, PK). This parameter is optional but recommended for certain endpoints.
|
useruid |
Your unique developer UID, provided on your dashboard. This identifies your account for API usage. |
api |
Your secret API key, which must remain confidential. Unauthorized access may result in a security breach. |
Error Responses
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}– Returned when the provided user ID is invalid or missing. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}– Returned when the API key is incorrect, expired, or not provided. -
{"error":"Server error or external API issue. Try again later."}– Returned when there is an internal server issue or problems with external dependencies.
| Region | Code |
|---|---|
| India | IND |
| Brazil | BR |
| Singapore | SG |
| Russia | RU |
| Indonesia | ID |
| Taiwan | TW |
| United States | US |
| Vietnam | VN |
| Thailand | TH |
| Middle East | ME |
| Pakistan | PK |
| CIS | CIS |
| Bangladesh | BD |
PlayerUid, region, useruid, and api parameters:
curl -X GET "https://hl-gaming-official-main-api.vercel.app/api?sectionName=AllData&PlayerUid=9351564274®ion=pk&useruid={user_uid}&api={hlgaming-api}"
{user_uid} with your unique User ID and {hlgaming-api} with your valid API key.
AllData section of the API into your apps and tools.
AccountInfo endpoint returns comprehensive account details such as player metrics, progression, and in-game status.
It is accessed via the base URL with
sectionName=AccountInfo and supports the following sub‑sections:
| Sub‑Section | Description |
|---|---|
AccountAvatarId |
ID of the player’s avatar image. |
AccountBPBadges |
Total number of BP Badges earned. |
AccountBPID |
Unique identifier for the BP system entry. |
AccountBannerId |
ID for the player’s banner graphic. |
AccountCreateTime |
Timestamp (epoch) for account creation. |
AccountEXP |
Total experience points the player has earned. |
AccountLastLogin |
Timestamp when the player last logged in. |
AccountLevel |
The current level of the player. |
AccountLikes |
Number of likes received on the player’s profile. |
AccountName |
The display name of the account holder. |
AccountRegion |
The region code of the account (e.g., PK). |
AccountSeasonId |
The current season identifier related to the account. |
AccountType |
Indicates the type of account (free, premium, etc.). |
BrMaxRank |
Maximum rank reached in Battle Royale mode. |
BrRankPoint |
Ranking points associated with Battle Royale mode. |
CsMaxRank |
Highest rank achieved in Competitive Squad mode. |
CsRankPoint |
Ranking points in Competitive Squad mode. |
EquippedWeapon |
An array holding the ID(s) of weapons currently equipped. |
ReleaseVersion |
The current release version identifier. |
ShowBrRank |
Boolean flag indicating if the Battle Royale rank is visible. |
ShowCsRank |
Boolean flag indicating if the Competitive Squad rank is visible. |
Endpoint Details
When called with valid credentials, the AccountInfo endpoint returns a JSON object with every sub‑section value clearly labeled. The response includes core metrics such as the player’s avatar ID, badge counts, experience points, level, and ranking information in both Battle Royale and Competitive Squad modes.
For instance, the AccountCreateTime uses epoch time format, and EquippedWeapon is returned as an array to allow for multiple equipped items.
Developers can use this endpoint for both basic display and deeper analysis of a player’s progress.
Example Output Response
The complete JSON response from a valid request will resemble:
You can also drill down into any specific sub‑section. For example, to retrieve just the player's name, a request with sectionName=AccountInfo and a sub‑section path AccountInfo/AccountName will return:
Error Responses
If there are issues with the request, the AccountInfo endpoint may return the following errors:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."} -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"} -
{"error":"Server error or external API issue. Try again later."}
The AccountProfileInfo endpoint is designed to provide expansive player profile details. This endpoint not only enables you to retrieve data regarding the player's current visual customization but also provides in-depth information on the active skills associated with the player's profile.
Access this endpoint using the base URL with the parameter sectionName=AccountProfileInfo. In addition, you have the capability to filter the returned results using the optional parameter subSec={sub sec}, allowing you to target specific sub‑sections of the overall profile data.
This comprehensive endpoint returns a JSON object containing two primary arrays:
- EquippedOutfit: An array that lists the numerical identifiers for each outfit item that is currently equipped by the player. Each number in the array corresponds to a unique item within the game's inventory database.
- EquippedSkills: An array holding the numerical identifiers for the active skills that the player has selected. This allows for quick assessment and updating of skill configurations.
Using the subSec={sub sec} filter, you can retrieve just one of these fields to reduce the response payload. For instance, if you only need the player's outfit details, you may specify subSec=EquippedOutfit. Similarly, subSec=EquippedSkills returns only the skills information.
In‑Depth Endpoint Usage and Details
Usage Overview: This endpoint allows developers to both view and update the player's profile data. It is particularly useful in applications where real‑time customization information is needed, such as live profile displays, gaming dashboards, or even update screens for player settings.
When no sub‑section filter is applied, the API returns the entire profile dataset encapsulated within the two arrays (EquippedOutfit and EquippedSkills). This is useful if a full profile dump is required for a deep analysis or when caching complete profile data.
Alternatively, the sub‑section filter (i.e., subSec={sub sec}) permits focused queries. This targeted request feature minimizes data volume and processing overhead on the client side. For example:
-
To retrieve only the list of outfit items (which might be useful for a visual display or for updating skin configurations), make a request with:
?sectionName=AccountProfileInfo&subSec=EquippedOutfit&PlayerUid={PlayerUid}®ion={region}&useruid={useruid}&api={api} -
For extracting only the active skills array, use:
?sectionName=AccountProfileInfo&subSec=EquippedSkills&PlayerUid={PlayerUid}®ion={region}&useruid={useruid}&api={api}
Data Structure:
-
EquippedOutfit: Returns an array such as [204000345, 203046040, 211048038, 205046027, 211036046, 214000000]. Each numeric identifier corresponds to a unique equipped item. -
EquippedSkills: Returns an array such as [16, 6201, 8, 1, 16, 1806, 8, 2, 16, 6906, 8, 3, 16, 5206]. Each number in this array signifies a particular skill that is active on the player's profile.
The design of this endpoint ensures that detailed profile customizations can be efficiently managed. It is ideal for applications that require real-time data retrieval with precise filtering capabilities.
Example Output Response
Below is a sample JSON output for a complete call to the AccountProfileInfo endpoint without any sub‑section filtering. This sample response demonstrates the full set of data values returned:
In contrast, if you filter the endpoint to return only the equipped outfit details using subSec=EquippedOutfit, the JSON response will focus solely on that sub‑section:
Likewise, if you filter by subSec=EquippedSkills, the endpoint will return only the array of equipped skills:
These examples demonstrate the flexibility and precision provided by the subSec parameter, allowing you to tailor data retrieval to your application’s specific needs.
Error Responses
When invoking the AccountProfileInfo endpoint, you may encounter errors if the request is not properly authenticated or if there is an issue with the external API service. The following error responses are commonly returned:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}– This error occurs when the provided user ID is either missing or invalid. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}– This indicates that your API key is incorrect, expired, or not registered properly. -
{"error":"Server error or external API issue. Try again later."}– Returned when there is an internal server error or a temporary issue with an external dependency. In such cases, retry the request after some time.
These error messages help in quickly diagnosing issues so that you can adjust your request parameters or authentication credentials accordingly.
The GuildInfo endpoint returns detailed information about a player's guild. It is designed to support both data display for user interfaces and in‑depth guild management analytics. This endpoint provides essential guild parameters including the maximum capacity, current member count, unique identifier, level, name, and owner of the guild.
Access the endpoint via the base URL by appending the following query parameters:
sectionName=GuildInfo: Indicates the specific endpoint for guild information.PlayerUid: The unique identifier for the player, which is used to look up the associated guild.region: The region code of the player's account (e.g.,NA,EU,PK).useruid: Your unique developer identifier provided on the dashboard.api: Your confidential API key used for authentication.
In addition to the basic URL structure, you can further utilize this endpoint for both read-only display and advanced analytics of guild data.
Detailed Parameter Breakdown and Usage
Parameter Breakdown: The following table lists the key guild-related parameters that are returned by this endpoint along with detailed descriptions:
| Parameter | Description |
|---|---|
GuildCapacity |
Indicates the maximum number of members that the guild can accommodate. This is useful for displaying guild size limits and for verifying whether the guild can accept new members. |
GuildID |
A unique identifier for the guild. This can be used for linking guild data across different endpoints or for performing further guild-specific actions. |
GuildLevel |
Represents the current level of the guild. Guild levels may unlock special privileges or visual distinctions in the game. |
GuildMember |
Indicates the current number of members in the guild. This value is dynamic and can change as players join or leave the guild. |
GuildName |
The name of the guild. This field is used for display purposes and for guild identification within the game. |
GuildOwner |
Specifies the unique identifier of the guild owner. This is the player who created the guild or has been assigned as its leader. |
Usage Notes:
- The endpoint is particularly useful for administrative dashboards, guild management tools, or any interface that displays real‑time guild information.
- Due to the sensitive nature of guild data, ensure that only authenticated and authorized requests are made.
- The returned data structure is JSON formatted, making it easy to integrate with modern web frameworks and mobile applications.
Deeper Details and Extended Explanation
This endpoint is engineered to support both quick data display and more advanced guild analytics. The key considerations include:
-
Dynamic Data Handling: The
GuildMemberfield is highly dynamic, reflecting real‑time changes as new members join or leave. Applications should handle this variability gracefully. - Data Aggregation: The complete response is designed to be parsed and stored for caching purposes if complete guild data needs to be aggregated over several requests.
-
Integration: Use the unique
GuildIDto cross-reference with other endpoints if additional guild statistics or historical data is required. This ID serves as the primary key for guild-related operations. - Scalability: Because guild sizes and levels can vary significantly from one account to another, this endpoint has been optimized to return only the required fields with minimal processing delay.
Developers are encouraged to examine the returned JSON structure carefully. The data can be integrated into front‑end displays, processed for analytics, or used to trigger notifications—such as when the guild reaches its maximum capacity.
Example Output Response
A typical JSON response from a successful call to the GuildInfo endpoint is as follows:
This JSON object includes:
- GuildCapacity: Maximum allowed members (e.g., 40).
- GuildID: A unique identifier, which in this example is a string, ensuring that the guild can be distinctly recognized.
- GuildLevel: Indicates the current guild level (e.g., 4).
- GuildMember: The current count of guild members (e.g., 39), which can be used to assess if the guild is close to reaching its capacity.
- GuildName: The name of the guild for display and verification purposes.
- GuildOwner: The unique identifier of the guild owner, which is crucial for administrative operations.
This clear and detailed output allows developers to validate the integration quickly and utilize the returned guild information for any required application logic.
Error Responses
In the event of an error, the GuildInfo endpoint may return one of the following responses to help diagnose and resolve the issue:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}– This error occurs if the providedPlayerUidor other authentication parameters are missing or invalid. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}– Returned when the API key provided does not match the expected credentials, is expired, or was not registered properly. -
{"error":"Server error or external API issue. Try again later."}– Indicates a problem on the server side or with external dependencies. These issues are typically temporary and may resolve upon retrying the request.
It is important to handle these errors gracefully in your application. Employ robust error handling mechanisms and consider implementing retry logic for transient errors.
Additional Integration Considerations
When integrating the GuildInfo endpoint into your application, consider the following:
- Caching: Since guild data may not change frequently, caching responses can enhance performance and reduce server load.
- Real‑Time Updates: For live guild dashboards, plan to poll this endpoint periodically or use server‑side push notifications if available.
- Security: Always ensure that your API key and other sensitive parameters are securely stored and transmitted over HTTPS.
-
Data Consistency: Cross‑verify critical fields like
GuildMemberandGuildCapacityto ensure that your application displays accurate guild status.
These considerations, combined with the detailed output provided by the endpoint, will help you build robust, scalable, and user-friendly guild management features.
The captainBasicInfo endpoint returns fundamental player metrics that are critical for in‑depth player analytics. It covers various aspects including account identification, experience, level, ranking, badge details, and more. The endpoint is accessed using the base URL with the parameter sectionName=captainBasicInfo. In addition, you can further refine your requests by using the subSec={sub sec} parameter to retrieve only specific pieces of data.
This endpoint is ideal for applications that require quick access to core player statistics, whether for display purposes on a dashboard, advanced data analytics, or monitoring player progress over time.
Deep Dive Explanation
When called, the captainBasicInfo endpoint returns a variety of key metrics. These include:
- accountId: The player’s unique account identifier.
- accountType: A numerical value representing the type of account (e.g., free or premium).
- badgeCnt and badgeId: Provides current badge statistics indicating the number and identifiers of earned badges.
- createAt: The timestamp indicating when the account was created.
- csMaxRank, csRank, and csRankingPoints: These fields represent competitive squad ranking data—useful for understanding the player’s performance in squad-based game modes.
- exp: The total experience points earned by the player. This serves as an important indicator of progression.
- headPic: A reference to the avatar image identifier used by the player.
- lastLoginAt: The timestamp of the last login, providing insights into the player’s activity.
- level: The current level of the player.
- liked: The number of likes the player profile has received.
- maxRank and rank: These fields provide information about the highest and current rank of the player.
- rankingPoints: Points accumulated which contribute to the overall ranking.
- region, releaseVersion, seasonId, showBrRank, showCsRank, and title: Additional contextual data that supplies further details about the account configuration and display options.
By utilizing the optional query parameter subSec={sub sec}, you can target specific portions of the data. For instance, if you are interested only in retrieving the accountId or the level, include subSec=accountId or subSec=level in your request URL.
This deep-dive functionality is particularly useful for reducing data payload when only a specific piece of information is required.
Usage and Sub‑Section Details
Full Endpoint Usage:
A call to captainBasicInfo without any sub‑section filter returns a complete JSON object with all metrics. This full dump is valuable for applications that require a holistic view of the player's statistics.
Sub‑Section Filtering:
By appending &subSec={sub sec} to your URL, you can isolate individual data fields. Examples include:
-
subSec=accountId– Returns only the player's unique account identifier. -
subSec=exp– Retrieves only the total experience points. -
subSec=level– Provides just the current level of the player. -
subSec=rankingPoints– Focuses on the ranking points data.
This filtering helps in tailoring the response to your application's specific data requirements, minimizing bandwidth consumption and processing time.
Data Structure: The complete JSON response contains key-value pairs for each metric, ensuring that developers have all the necessary data to perform analytics, display summaries, or trigger further in-game actions based on player performance.
Example Output Response
Below is a sample JSON response from a successful call to the captainBasicInfo endpoint without sub‑section filtering:
As an example of sub‑section filtering, consider a query with subSec=level. The endpoint will return only the player's current level:
Similarly, you can retrieve any individual metric like exp, nickname, or rankingPoints using the same sub‑section approach.
Error Responses
The captainBasicInfo endpoint will return standard error messages if issues occur during the request. Common error responses include:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}– Returned when thePlayerUidor related authentication parameters are either missing or incorrect. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}– Indicates that the API key is not valid, has expired, or was not provided. -
{"error":"Server error or external API issue. Try again later."}– Signifies an internal server error or a problem with external dependencies. Retrying the request may resolve this issue.
Implement robust error handling routines in your application to detect these errors and provide clear feedback to end users or log them for further analysis.
Additional Integration Considerations
When integrating the captainBasicInfo endpoint, consider the following best practices:
- Caching Data: Given that many of these metrics do not change rapidly, consider caching responses to reduce API load and improve performance.
- Real‑Time Updates: For features that rely on up‑to‑date metrics (such as live dashboards), set up frequent polling or subscribe to server‑push notifications if available.
- Secure Authentication: Always use secure connections (HTTPS) for API calls, and protect your API keys and user credentials.
-
Granular Data Retrieval: Utilize the
subSecparameter to retrieve only the data you need, which can reduce network overhead and speed up data processing. -
Data Consistency Checks: Verify returned values (such as
lastLoginAttimestamps and level progress) to ensure your application’s display is consistent and accurate.
These practices will help you build a robust and efficient integration with the HL Gaming Official API.
The creditScoreInfo endpoint provides vital financial details for a player's account. This endpoint returns the player's current credit score as well as timing data used to define the period over which the credit score is computed. It is designed for applications such as in‑game credit systems, financial analytics dashboards, and other features that require detailed economic metrics.
Access this endpoint using the base URL with the parameter sectionName=creditScoreInfo. In addition, you can narrow the response further using the optional subSec={sub sec} parameter. For example, if only the credit score value is needed, you might include subSec=creditScore in your query.
This endpoint is essential for developers looking to implement detailed financial analytics and ensure that the timing of credit calculations aligns with in‑game events and promotions.
Detailed Information and Field Breakdown
Upon a successful request, the JSON response will contain the following fields:
- creditScore: A numeric value representing the current credit standing of the player. This score is used to determine a player's financial credibility within the game and can impact in‑game transactions or promotions.
- periodicSummaryStartTime: A timestamp (typically in epoch format) indicating the start of the period over which the credit score is calculated. This field is important for understanding the timeframe of the financial summary.
- periodicSummaryEndTime: A timestamp (in epoch format) marking the end of the calculation period. Together with the start time, this allows for precise financial analytics and trend analysis.
Sub‑Section Filtering: By adding the optional query parameter subSec={sub sec} to your API call, you can request only specific fields. For example:
-
To get only the credit score, use
subSec=creditScore. -
To retrieve only the summary start and end times, use
subSec=periodicSummary.
This filtering can optimize data transmission and processing, especially when your application needs only a subset of the full response.
Example Output Response
Below is an example of the full JSON response for a standard call to the creditScoreInfo endpoint:
In cases where you are only interested in a specific sub‑section, for example just the credit score value, a call with the sub‑section filter (subSec=creditScore) might return:
Similarly, to focus on the timing fields, you can set subSec=periodicSummary to get only the periodicSummaryStartTime and periodicSummaryEndTime values:
These examples illustrate the endpoint's flexibility, allowing you to tailor the data output to the specific needs of your application.
Error Responses
If an error occurs during the request to the creditScoreInfo endpoint, the API may return one of the following error messages to help you diagnose and resolve the problem:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}– This error is returned when thePlayerUidor other authentication parameters are missing or invalid. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}– This message appears if the provided API key is incorrect, expired, or not recognized. -
{"error":"Server error or external API issue. Try again later."}– This error indicates that an internal server error or external dependency issue occurred. In such cases, retrying the request after some time is recommended.
Always implement robust error handling to manage these responses appropriately within your application.
Additional Integration Considerations
When integrating the creditScoreInfo endpoint into your application, consider the following best practices:
- Response Caching: Since financial summary data may not change on a per-second basis, caching responses can reduce load times and server strain.
- Data Security: Always ensure that your API key and sensitive parameters are transmitted securely using HTTPS.
-
Optimized Data Retrieval: Use the sub‑section filter (
subSec) to retrieve only the data you need, reducing the overall payload and speeding up response times. -
Time Synchronization: Verify that the timestamps provided (
periodicSummaryStartTimeandperiodicSummaryEndTime) are correctly synchronized with your application’s time settings to ensure accurate financial analytics. - Error Handling and Retries: Implement retry logic for transient errors such as server issues, and log detailed error information for troubleshooting.
These integration considerations will help ensure that your implementation of the creditScoreInfo endpoint is both robust and efficient.
The petInfo endpoint provides an extensive set of attributes related to a player’s in-game pet. This data includes various essential pet characteristics such as the pet’s experience points, level progression, active skill, skin selection, and unique identifier. This endpoint serves a crucial role in visualizing and managing pet-related game mechanics within any client or external application.
To access this endpoint, supply the base parameter sectionName=petInfo along with necessary identifiers: PlayerUid, region, useruid, and a valid api key.
Developers can also use the optional subSec parameter to retrieve specific subsections of the pet data. For instance, subSec=level will return just the pet’s level, optimizing the response payload when only partial data is needed.
Full Field Breakdown
The response from this endpoint includes a structured JSON object with the following key fields:
-
exp: An integer representing the total amount of experience points the pet has accumulated over its lifetime. This field is crucial for understanding the pet's overall progression and proximity to the next level. -
id: A unique numerical identifier that corresponds to the specific pet instance owned by the player. This ID can be used for cross-referencing with other pet-related APIs or databases. -
isSelected: A boolean value indicating whether the pet is currently selected or equipped by the player in active gameplay. A value oftruemeans the pet is active;falsemeans it is not in use. -
level: Indicates the pet’s current level, determined by accumulated experience. Leveling up may unlock new abilities or enhance pet stats. -
selectedSkillId: This field holds the identifier for the pet’s currently active or equipped skill. This can be mapped against a skill database to determine what ability the pet is using. -
skinId: Represents the visual skin currently applied to the pet. This allows developers to retrieve or render the corresponding visual asset in user interfaces.
Each field enables flexible integration into applications, such as building pet dashboards, inventory systems, or real-time visualizations for players.
Optional Subsection Filtering
You can use the optional parameter subSec to retrieve only specific parts of the data, for example:
subSec=level– Returns only the pet's level.subSec=exp– Returns only the current XP value.subSec=selectedSkillId– Fetches only the active skill ID.
Example Output Response
Here’s an example JSON response from a typical petInfo call:
Example using subSec=level:
Example using subSec=selectedSkillId:
Error Responses
In the case of failure or misconfiguration, the following error messages may be returned:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}
→ This indicates the providedPlayerUidoruseruidis invalid or mismatched. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}
→ Indicates the API key is either missing, malformed, or expired. -
{"error":"Server error or external API issue. Try again later."}
→ A server-side failure or third-party connection issue. Retry the request after some time.
Advanced Integration & Best Practices
When integrating the petInfo endpoint into a larger system or frontend UI, consider the following tips and strategies:
- Data Caching: Pet data doesn't change every second. Cache responses to avoid repetitive calls and improve performance.
- Skin & Skill Mapping: Build a lookup database or use additional endpoints to map
skinIdandselectedSkillIdinto meaningful names or icons. - UI Personalization: Use
isSelectedto highlight active pets in the interface, allowing dynamic toggling or filtering. - Error Handling: Use fallback UI messages and retry logic if the endpoint returns temporary errors.
- Secure Requests: Always ensure you use HTTPS and securely store your
apikey. - Usage Monitoring: Monitor usage fields (
usedToday,remainingToday) to avoid hitting rate limits or triggering quota-based throttling.
These practices ensure reliable, efficient, and visually engaging implementations of pet-related features in your application.
The AllData endpoint is designed for power users, developers, and analytics platforms that require a **complete and consolidated dump** of a player's entire profile. It seamlessly compiles data from multiple core endpoints including:
- AccountInfo
- AccountProfileInfo
- GuildInfo
- captainBasicInfo
- creditScoreInfo
- petInfo
- socialinfo
This unified structure saves bandwidth and development time by reducing the need to make multiple separate requests. It is ideal for profile inspection, dashboards, leaderboards, and analytical tools.
Complete Data Structure & Use Cases
Returned Objects Overview
-
AccountInfo: Includes public-facing stats and ID references. Useful for displaying nameplates, player levels, badges, and avatar appearance.AccountAvatarId– Player's current avatar.AccountEXP– Total experience points accumulated.AccountLevel– Level achieved based on EXP.AccountName– Current in-game display name (UTF-8, emojis supported).BrRankPoint,CsRankPoint– Points earned in Battle Royale and Clash Squad respectively.ShowBrRank,ShowCsRank– Booleans to determine whether the player publicly displays ranks.
-
AccountProfileInfo: Aesthetic loadouts and equipped skills.EquippedOutfit– Array of item IDs representing cosmetics.EquippedSkills– Complex array storing skill ID and slot mapping.
-
GuildInfo: Provides info about guild affiliations and status.GuildID,GuildName– Identifiers for the guild.GuildLevel,GuildMember– Progress and size of the guild.
-
captainBasicInfo: Leaderboard-style metrics such as titles, badges, login timestamps, and competitive standing.nickname,level,rankingPoints,maxRank- Also includes the player's title, avatar, and version metadata.
-
creditScoreInfo: Indicates disciplinary status and account health.creditScore– Out of 100, with 100 being ideal.periodicSummaryStartTime,periodicSummaryEndTime– Timestamps defining the evaluation window.
-
petInfo: Virtual companion stats.exp,level,selectedSkillId,skinId- Pets enhance gameplay through skills and cosmetics.
-
socialinfo: Social personalization.AccountLanguage– Client-side language setting (e.g.,en,es).AccountPreferMode– Preferred game mode.AccountSignature– Custom player bio or message.
Usage Metrics Block
This section tracks rate limits and daily usage:
Sample Integration Scenarios
- Dashboard Interfaces – Pull everything at once to show a holistic player view.
- Admin Panels – Useful for moderation tools, rank checks, and performance audits.
- Mobile Apps – Reduce calls with one endpoint; ideal for load-time optimization.
- Analytics Engines – Batch process data to detect trends, identify outliers, and cluster players.
- Backup Snapshots – Take complete profile dumps for auditing or migration.
Performance Note:
This is a heavy endpoint. Use responsibly and avoid frequent polling. Consider caching or staggering refresh intervals.
Example Full JSON Response
Here’s an expanded JSON sample for developers to simulate the output and map fields on UI:
Scroll within the box to view more keys. Use an online JSON formatter for full parsing if needed.
Optional Sub-Data Filtering with subSec
You may pass the subSec parameter to retrieve only one subsection from the full response:
subSec=GuildInfo– Returns only guild data.subSec=AccountProfileInfo– Isolate aesthetic loadouts.subSec=socialinfo– Retrieve just the social layer.
This improves performance and allows you to build lazy-loading components.
Error Responses
AllData may return one of the following errors:
-
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}
→ Authentication mismatch. Ensure the user ID is correct and belongs to the specified region. -
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}
→ Use a valid key and never expose it in client-side apps. -
{"error":"Server error or external API issue. Try again later."}
→ Transient issue or rate limit breach. Apply retry logic and exponential backoff.
The BanCheck endpoint is specifically designed to allow developers and administrators to quickly verify whether a Free Fire account has been flagged or banned. Unlike other endpoints, the region parameter is not required, making it faster and more efficient for use cases where regional filtering is unnecessary. This endpoint can be invoked with the sectionName=BanCheck parameter.
How BanCheck Works
The BanCheck endpoint operates by verifying the status of the provided Free Fire account. It checks if the account is currently banned or flagged for any reason. Upon successful query execution, the response includes the following key information:
status: Indicates the result of the request—whether it was successful or not.is_banned: A boolean value—trueif the account is banned andfalseif the account is not banned (i.e., clean).message: A human-readable string providing additional information about the current status of the account (e.g., “Account is clean” or “Account is banned due to misconduct”).period: Indicates the duration of the ban if it is temporary. If the ban is permanent, this field will returnnull.credits: Credits or acknowledgment to the API provider, in this case, HL Gaming Official.
Error Responses
While the BanCheck endpoint is generally reliable, there are cases where error responses may occur. The following errors are commonly encountered:
{"error":"Auth Failed! Please Check Your User ID & Try Again.."}
– This error occurs when authentication fails, usually due to an invalid or missingUser IDor mismatched credentials.{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}
– Indicates that the provided API key is invalid. Ensure that you are using a valid key obtained from the official source.{"error":"Server error or external API issue. Try again later."}
– This error suggests an issue with the API server or external dependencies. Retry the request after a short interval.
The HL Gaming API platform provides flexible pricing and access tiers to meet the diverse needs of individual developers, game studios, and commercial applications.
Whether you're building a lightweight stats viewer or a full-featured dashboard, our plans scale with your usage. All tiers are optimized for performance and security, with fair daily limits and extended functionality available for upgraded users.
Explore our API pricing options and unlock full access:
After selecting a plan, your API key will be upgraded in real-time, unlocking access to premium endpoints and extended usage limits — no extra integration required.
- Free Tier: Ideal for testing and personal use. Limited daily requests, full core access.
- Pro & Ultra Tiers: Higher daily limits, access to exclusive data, priority response speeds, and support.
- Enterprise: Custom access plans tailored to studios or heavy-load apps. Contact us directly for pricing.
Upgrade today and take full control over your integration with reliable and blazing-fast API responses, backed by HL Gaming’s official platform.
AllData API endpoint with your credentials. This will fetch a full detailed report for the given player UID, region, and your dev keys.
The
socialinfoendpoint provides access to a player's public and preference-based social profile fields. It is mainly used for retrieving or modifying the player’s social settings such as preferred game mode, signature, and display language.This endpoint can be triggered using the parameter
sectionName=socialinfo, along with required identifiers likePlayerUid,region,useruid, and a validapikey.Developers can use this data to personalize social sections within an application, offer localized content, or allow users to update their signature through a form-based interface.
Fields & Data Structure
The JSON response contains the following keys:
AccountLanguage: A string representing the player’s selected display language (e.g.,enfor English,esfor Spanish). This helps localize UI elements in your client.AccountPreferMode: Indicates the game mode the player most prefers. Example values may includeBR(Battle Royale),CS(Clash Squad), orOther. This helps in matchmaking and content prioritization.AccountSignature: The player’s current profile signature or bio. This is often visible to friends or other players and must follow game community guidelines.Optional Filtering with
subSecYou can specify a single field to fetch using
subSec. Examples:subSec=AccountLanguage– Returns only the player's selected language.subSec=AccountSignature– Retrieves just the current profile signature.Example Output Responses
Full JSON response example:
Using
subSec=AccountPreferMode:Updating Social Fields
This endpoint also allows updates via POST (or in some implementations, query-based updates). You can update a user’s:
BR,CS, orTraining.en,fr,de, etc.Example update (if supported via query):
⚠️ Note: Make sure all user-submitted data is sanitized before updating to prevent abuse or injection.
Error Responses
Here are the most common error messages returned by the
socialinfoendpoint:{"error":"Auth Failed! Please Check Your User ID & Try Again.."}→ Indicates the user ID or UID is missing or invalid.
{"error":"Invalid API key. Obtain An official key form https://www.hlgamingofficial.com/p/api.html"}→ Your API key is either expired or improperly passed.
{"error":"Server error or external API issue. Try again later."}→ Server-side fault. May resolve itself automatically within minutes.
Integration Tips & Use Cases
AccountLanguageto display UI in the correct language automatically.AccountPreferModeto improve lobby satisfaction or match relevance.AccountSignatureon leaderboard and profile cards to enhance personalization.AccountSignaturebefore submitting. Filter offensive content using client-side or backend profanity filters.usageobject to avoid exceeding daily API quotas.