r6-data.js
Advanced tools
R6 (Rainbow Six Siege) API wrapper for player stats, operators, maps, ranks, seasons, charms, skins and game datas. Last Updated Y11S1
Rainbow Six Siege (R6) API wrapper - Get player stats, operators, maps, ranks, seasons, charms and more. Full TypeScript support included. Last updated Y11S1
npm i r6-data.js
Notice: Due to the abuse of the available APIs, it has been decided that from now on, in order to use both the package and the APIs, it is necessary to register on the website and create an API key.
To use this package, you need an API Key. You can obtain your API Key by registering on the official website: r6data.eu. Once registered, you can generate your personal API Key from your account settings.
Note: This API Key must be passed as the first argument to all get methods.
Website where you can directly track your stats and also check the all infos that gives r6-data.js. Entire website is based on r6-data.js.
Visit the official website: r6data.eu
Full TypeScript support with complete type definitions and IntelliSense.
// ES6 imports
import * as r6 from 'r6-data.js';
import { getAccountInfo, AccountInfoParams, PlatformType } from 'r6-data.js';
const apiKey = 'YOUR_API_KEY';
// Usage with types
const params: AccountInfoParams = {
nameOnPlatform: 'PlayerName',
platformType: 'uplay' as PlatformType
};
const accountInfo = await r6.getAccountInfo(apiKey, params);
// CommonJS (still supported)
const r6 = require('r6-data.js');
const apiKey = 'YOUR_API_KEY';
const accountInfo = await r6.getAccountInfo(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay'
});
The getAccountInfo() function allows you to retrieve player profile data from the official Rainbow Six Siege API. This function is specifically designed for retrieving account information such as player level, experience, clearance level, and profile settings.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get player account information
const accountInfo = await r6Info.getAccountInfo(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay'
});
console.log('Account information:', accountInfo);
return accountInfo;
} catch (error) {
console.error('Error retrieving account information:', error.message);
}
}
main();
The getAccountInfo() function accepts the API Key and an object with the following parameters:
apiKey: (Required) Your API Key from r6data.eunameOnPlatform: (Required) The player's name on the platformplatformType: (Required) The platform type - "uplay", "psn", or "xbl"When using getAccountInfo(), you'll receive data about the player's profile, including:
The getIsBanned() function allows you to check if a player is currently banned from Rainbow Six Siege.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Check if player is banned
const banStatus = await r6Info.getIsBanned(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay'
});
console.log('Ban status:', banStatus);
return banStatus;
} catch (error) {
console.error('Error checking ban status:', error.message);
}
}
main();
The getIsBanned() function accepts the API Key and an object with the following parameters:
apiKey: (Required) Your API Key from r6data.eunameOnPlatform: (Required) The player's name on the platformplatformType: (Required) The platform type - "uplay", "psn", or "xbl"When using getIsBanned(), you'll receive data indicating the player's ban status.
The getPlayerStats() function allows you to retrieve detailed gameplay statistics from the official Rainbow Six Siege API. This function is specifically designed for retrieving player performance data across different game modes.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get player statistics
const playerStats = await r6Info.getPlayerStats(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay',
platform_families: 'pc'
});
console.log('Player statistics:', playerStats);
// Get player statistics for ranked mode only
const rankedStats = await r6Info.getPlayerStats(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay',
platform_families: 'pc',
board_id: 'ranked'
});
console.log('Ranked statistics:', rankedStats);
return rankedStats;
} catch (error) {
console.error('Error retrieving player statistics:', error.message);
}
}
main();
The getPlayerStats() function accepts the API Key and an object with the following parameters:
apiKey: (Required) Your API Key from r6data.eunameOnPlatform: (Required) The player's name on the platformplatformType: (Required) The platform type - "uplay", "psn", or "xbl"platform_families: (Required) The platform family - "pc" or "console"board_id: (Optional) The game mode to filter statistics - "casual", "event", "warmup", "standard", or "ranked"When using getPlayerStats(), you'll receive detailed gameplay statistics, including:
You can filter these statistics by game mode using the board_id parameter:
casual: Statistics for casual matchesevent: Statistics for limited-time eventswarmup: Statistics for warmup matchesstandard: Statistics for standard matchesranked: Statistics for ranked competitive matchesThe getSeasonalStats() function allows you to get detailed rank points history and seasonal progression for a specific player in the current season. Includes timestamp, rank information, RP values, and rank images
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get seasonal statistics for a player
const seasonalStats = await r6Info.getSeasonalStats(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay'
});
console.log('Seasonal statistics:', seasonalStats);
return seasonalStats;
} catch (error) {
console.error('Error retrieving seasonal statistics:', error.message);
}
}
main();
The getSeasonalStats() function accepts the API Key and an object with the following parameters:
apiKey: (Required) Your API Key from r6data.eunameOnPlatform: (Required) The player's name on the platformplatformType: (Required) The platform type - "uplay", "psn", or "xbl" {
"data": {
"history": {
"metadata": {
"key": "RankPoints",
"name": "Rank Points",
"description": null
},
"data": [
[
"2025-10-14T21:43:27.315+00:00",
{
"displayName": "Rank Points",
"metadata": {
"rank": "PLATINUM II",
"imageUrl": "https://r6data.eu/assets/img/r6_ranks_img/platinum-2.webp",
"color": "#44ccc2"
},
"value": 3300,
"displayValue": "3,300",
"displayType": "Number"
}
],
[
"2025-10-14T21:12:55.821+00:00",
{
"displayName": "Rank Points",
"metadata": {
"rank": "PLATINUM II",
"imageUrl": "https://r6data.eu/assets/img/r6_ranks_img/platinum-2.webp",
"color": "#44ccc2"
},
"value": 3302,
"displayValue": "3,302",
"displayType": "Number"
}
]
]
},
"leaderboard": null,
"expiryDate": "0001-01-01T00:00:00+00:00",
"bestMatches": null
}
The getOperatorStats() function allows you to get detailed operator statistics for a specific player.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get operator statistics for a player
const operatorStats = await r6Info.getOperatorStats(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay',
// seasonYear: 'Y9S4', // Optional
// modes: 'ranked' // Optional, default is 'ranked'
});
console.log('Operator statistics:', operatorStats);
return operatorStats;
} catch (error) {
console.error('Error retrieving operator statistics:', error.message);
}
}
main();
The getOperatorStats() function accepts the API Key and an object with the following parameters:
apiKey: (Required) Your API Key from r6data.eunameOnPlatform: (Required) The player's name on the platformplatformType: (Required) The platform type - "uplay", "psn", or "xbl"seasonYear: (Optional) Season year (e.g., Y9S4, Y10S4)modes: (Optional) Game mode (ranked, casual, unranked). Default is 'ranked'.The response contains detailed statistics for each operator played by the user.
The getGameStats() function allows you to get real-time player count statistics across all platforms including Steam, Ubisoft Connect, PlayStation, Xbox, and total player counts
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get general game statistics
const gameStats = await r6Info.getGameStats(apiKey);
console.log('Game statistics:', gameStats);
return gameStats;
} catch (error) {
console.error('Error retrieving game statistics:', error.message);
}
}
main();
{
"steam": {
"concurrent": 33631,
"estimate": 33631
},
"crossPlatform": {
"totalRegistered": 85000000,
"monthlyActive": 15300000,
"trendsEstimate": 175666,
"platforms": {
"pc": 6885000,
"playstation": 5355000,
"xbox": 3060000
}
},
"ubisoft": {
"onlineEstimate": 127739
},
"lastUpdated": "2025-10-15T22:39:38.636Z"
}
The getPlayerComparisons() function compares Rainbow Six Siege statistics between multiple players, providing rankings and comparison metrics.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
const comparison = await r6Info.getPlayerComparisons(apiKey, {
players: [
{ nameOnPlatform: 'Player1', platformType: 'uplay' },
{ nameOnPlatform: 'Player2', platformType: 'uplay' }
],
platform_families: 'pc',
board_id: 'ranked', // Optional
compareFields: ['kills', 'deaths', 'wins', 'losses'] // Optional
});
console.log('Comparison results:', comparison.comparison_summary.field_comparisons);
} catch (error) {
console.error('Error during comparison:', error.message);
}
}
main();
apiKey: (Required) Your API Key from r6data.euplayers: (Required) Array of player objects with nameOnPlatform and platformTypeplatform_families: (Required) "pc" or "console"board_id: (Optional) Game mode filter - "casual", "ranked", etc.compareFields: (Optional) Specific stats to compare (default: kills, deaths, wins, losses, etc.)Returns comparison data with player stats, field rankings (highest/lowest/average), and metadata including success/failure counts.
The createDiscordR6Webhook() function allows you to send Rainbow Six Siege player statistics directly to a Discord channel using webhooks. This creates formatted embeds with player stats that can be customized with various options.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// First, get player statistics
const playerStats = await r6Info.getPlayerStats(apiKey, {
nameOnPlatform: 'PlayerName',
platformType: 'uplay',
platform_families: 'pc'
});
// Send stats to Discord webhook
const webhookResult = await r6Info.createDiscordR6Webhook(
'https://discord.com/api/webhooks/YOUR_WEBHOOK_ID/YOUR_WEBHOOK_TOKEN',
playerStats,
{
playerName: 'PlayerName',
title: 'Rainbow Six Siege Stats',
message: 'Here are the latest R6 stats!',
color: 0xF99E1A, // Orange color
avatarUrl: 'https://example.com/avatar.png'
}
);
console.log('Webhook sent successfully:', webhookResult);
} catch (error) {
console.error('Error sending webhook:', error.message);
}
}
main();
The createDiscordR6Webhook() function accepts the following parameters:
webhookUrl: (Required) The Discord webhook URLplayerData: (Required) Player statistics data from getPlayerStats() or getAccountInfo()options: (Required) Configuration object with the following properties:
playerName: (Required) The player's name to displaytitle: (Optional) Custom title for the embed (default: "Rainbow Six Siege Stats")message: (Optional) Custom message content above the embedcolor: (Optional) Embed color in hexadecimal format (default: 0xF99E1A)avatarUrl: (Optional) URL for the player's avatar thumbnailThe function automatically detects and formats different data sources:
Ubisoft API data: From getPlayerStats() - displays ranked/standard statistics
Steam data: Custom Steam-formatted statistics
Custom data: Any custom statistics object
To use this function, you need to create a webhook in your Discord server:
createDiscordR6Webhook() functionThe getSearchAll() function allows you to search across all Rainbow Six Siege entities (operators, weapons, maps, seasons, charms, and attachments) with a single query. This is useful for finding relevant information across multiple categories at once.
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Search for all entities containing "black"
const searchResults = await r6Info.getSearchAll(apiKey, 'black');
console.log('Search results summary:', searchResults.summary);
// Access specific result categories
console.log('Operator results:', searchResults.results.operators);
console.log('Weapon results:', searchResults.results.weapons);
console.log('Map results:', searchResults.results.maps);
console.log('Season results:', searchResults.results.seasons);
console.log('Charm results:', searchResults.results.charms);
console.log('Attachment results:', searchResults.results.attachments);
// Search for a specific operator
const operatorSearch = await r6Info.getSearchAll(apiKey, 'ash');
console.log('Ash search results:', operatorSearch);
// Search for a specific map
const mapSearch = await r6Info.getSearchAll(apiKey, 'bank');
console.log('Bank search results:', mapSearch);
} catch (error) {
console.error('Error during search:', error.message);
}
}
main();
The getSearchAll() function accepts the API Key and a query:
apiKey: (Required) Your API Key from r6data.euquery: (Required) The search term to query across all entitiesThe function returns a structured object containing:
Each result includes an entity_type field indicating its category, along with relevant data fields for that entity type.
The getRanks() function supports retrieving rank information across different versions of the game's ranking system, from v1 to v6. This flexibility allows users to query rank data that aligns with specific game seasons or ranking system updates. Here are examples demonstrating how to use the getRanks() function for each version, including filtering options for min_mmr and max_mmr.
v1: Until Y1S3 | #3 | Skull Rain
v2: Y1S4 | #4 | Red Crow
v3: Y2S1 - Y4S2 | #5 - #14 | Velvet Shell - Phantom Sight
v4: Y4S3 - Y6S2 | #15 - #22 | Ember Rise - North Star
v5: Y6S3 - Y7S3 | #23 - #27 | Crystal Guard - Brutal Swarm
V6: Y7S4+ | #28+ | Solar Raid+ (Ranked 2.0)
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
const ranksV1 = await r6Info.getRanks(apiKey, { version: 'v1' });
console.log('All ranks for version v1:', ranksV1);
const filteredRanksV1 = await r6Info.getRanks(apiKey, { min_mmr: 2000, max_mmr: 2500, version: 'v1' });
console.log('Filtered ranks for version v1:', filteredRanksV1);
} catch (error) {
console.error('Error while requesting ranks:', error.message);
}
}
main();
getRanks() function with the version parameter set to 'v1' to retrieve all ranks for version 1 of the ranking system. We also demonstrate filtering the ranks by specifying the min_mmr and max_mmr parameters to get ranks within a specific MMR range.
For the others versions you can replace the v1 with v2, v3... and the others parameters
The getServiceStatus() function allows you to retrieve the current status of the Rainbow Six Siege game servers. This information can be useful for monitoring the health and availability of the game service. Here's an example of how to use the getServiceStatus() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
const serviceStatus = await r6Info.getServiceStatus(apiKey);
console.log('Service status:', serviceStatus);
} catch (error) {
console.error('Error while requesting service status:', error.message);
}
}
main();
The getMaps() function allows you to retrieve information about the maps available in Rainbow Six Siege. You can get a list of all maps or filter the maps based on specific criteria. Here's an example of how to use the getMaps() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all maps
const maps = await r6Info.getMaps(apiKey);
console.log('All maps:', maps);
// Filter maps by name
const filteredMapsByName = await r6Info.getMaps(apiKey, { name: 'Bank' });
console.log('Maps filtered by name:', filteredMapsByName);
// Filter maps by location
const filteredMapsByLocation = await r6Info.getMaps(apiKey, { location: 'USA' });
console.log('Maps filtered by location:', filteredMapsByLocation);
// Filter maps by release date
const filteredMapsByReleaseDate = await r6Info.getMaps(apiKey, { releaseDate: '2015-12-01' });
console.log('Maps filtered by release date:', filteredMapsByReleaseDate);
// Filter maps by playlists
const filteredMapsByPlaylists = await r6Info.getMaps(apiKey, { playlists: 'ranked' });
console.log('Maps filtered by playlists:', filteredMapsByPlaylists);
// Filter maps by rework status
const filteredMapsByRework = await r6Info.getMaps(apiKey, { mapReworked: true });
console.log('Maps filtered by rework status:', filteredMapsByRework);
} catch (error) {
console.error('Error while requesting maps:', error.message);
}
}
main();
Retrieving all maps by calling getMaps() without any parameters.
Filtering maps by name using the name parameter.
Filtering maps by location using the location parameter.
Filtering maps by release date using the releaseDate parameter.
Filtering maps by playlists using the playlists parameter.
Filtering maps by rework status using the mapReworked parameter.
You can use these filtering options individually or combine them to retrieve specific subsets of maps based on your requirements.
The getOperators() function allows you to retrieve information about the operators available in Rainbow Six Siege. You can get a list of all operators or filter the operators based on specific criteria. Here's an example of how to use the getOperators() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all operators
const operators = await r6Info.getOperators(apiKey);
console.log('All operators:', operators);
// Filter operators by name
const filteredOperatorsByName = await r6Info.getOperators(apiKey, { name: 'Ash' });
console.log('Operators filtered by name:', filteredOperatorsByName);
// Filter operators by safe name
const filteredOperatorsBySafeName = await r6Info.getOperators(apiKey, { safename: 'recruit' });
console.log('Operators filtered by safe name:', filteredOperatorsBySafeName);
// Filter operators by real name
const filteredOperatorsByRealName = await r6Info.getOperators(apiKey, { realname: 'Eliza Cohen' });
console.log('Operators filtered by real name:', filteredOperatorsByRealName);
// Filter operators by birthplace
const filteredOperatorsByBirthplace = await r6Info.getOperators(apiKey, { birthplace: 'Jerusalem, Israel' });
console.log('Operators filtered by birthplace:', filteredOperatorsByBirthplace);
// Filter operators by age
const filteredOperatorsByAge = await r6Info.getOperators(apiKey, { age: 33 });
console.log('Operators filtered by age:', filteredOperatorsByAge);
// Filter operators by date of birth
const filteredOperatorsByDateOfBirth = await r6Info.getOperators(apiKey, { date_of_birth: '1984-12-24' });
console.log('Operators filtered by date of birth:', filteredOperatorsByDateOfBirth);
// Filter operators by season introduced
const filteredOperatorsBySeasonIntroduced = await r6Info.getOperators(apiKey, { season_introduced: 'Y1S1' });
console.log('Operators filtered by season introduced:', filteredOperatorsBySeasonIntroduced);
} catch (error) {
console.error('Error while requesting operators:', error.message);
}
}
main();
getOperators() without any parameters.name parameter.safename parameter.realname parameter.birthplace parameter.age parameter.date_of_birth parameter.season_introduced parameter.You can get the operator url icon via r6Info.getOperators(), is in the json response.
The getSeasons() function allows you to retrieve information about the seasons in Rainbow Six Siege. You can get a list of all seasons or filter the seasons based on specific criteria. Here's an example of how to use the getSeasons() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all seasons
const seasons = await r6Info.getSeasons(apiKey);
console.log('All seasons:', seasons);
// Filter seasons by name
const filteredSeasonsByName = await r6Info.getSeasons(apiKey, { name: 'Black Ice' });
console.log('Seasons filtered by name:', filteredSeasonsByName);
// Filter seasons by map
const filteredSeasonsByMap = await r6Info.getSeasons(apiKey, { map: 'Yacht' });
console.log('Seasons filtered by map:', filteredSeasonsByMap);
// Filter seasons by operators
const filteredSeasonsByOperators = await r6Info.getSeasons(apiKey, { operators: 'Buck, Frost' });
console.log('Seasons filtered by operators:', filteredSeasonsByOperators);
// Filter seasons by weapons
const filteredSeasonsByWeapons = await r6Info.getSeasons(apiKey, { weapons: 'C8-SFW, Super 90' });
console.log('Seasons filtered by weapons:', filteredSeasonsByWeapons);
} catch (error) {
console.error('Error while requesting seasons:', error.message);
}
}
main();
Retrieving all seasons by calling getSeasons() without any parameters.
name parameter.map parameter.operators parameter.weapons parameter.The getAttachment() function allows you to retrieve information about the attachments available in Rainbow Six Siege. You can get a list of all attachments or filter the attachments based on specific criteria. Here's an example of how to use the getAttachment() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all attachments
const attachments = await r6Info.getAttachment(apiKey);
console.log('All attachments:', attachments);
// Filter attachments by name
const filteredAttachmentsByName = await r6Info.getAttachment(apiKey, { name: 'Red Dot Sight' });
console.log('Attachments filtered by name:', filteredAttachmentsByName);
// Filter attachments by style
const filteredAttachmentsByStyle = await r6Info.getAttachment(apiKey, { style: 'colour' });
console.log('Attachments filtered by style:', filteredAttachmentsByStyle);
// Filter attachments by rarity
const filteredAttachmentsByRarity = await r6Info.getAttachment(apiKey, { rarity: 'common' });
console.log('Attachments filtered by rarity:', filteredAttachmentsByRarity);
// Filter attachments by availability
const filteredAttachmentsByAvailability = await r6Info.getAttachment(apiKey, { availability: 'removed' });
console.log('Attachments filtered by availability:', filteredAttachmentsByAvailability);
} catch (error) {
console.error('Error while requesting attachments:', error.message);
}
}
main();
Retrieving all attachments by calling getAttachment() without any parameters.
name parameter.style parameter.rarity parameter.availability parameter.const r6Info = require('r6-data.js');
const apiKey = 'YOUR_API_KEY';
// Get all charms
const charms = await r6Info.getCharms(apiKey);
console.log('All charms:', charms);
// Filter charms by specific criteria
const filteredCharms = await r6Info.getCharms(apiKey, {
name: 'Chibi',
collection: 'Year 1',
rarity: 'legendary',
availability: 'available',
bundle: 'Pro League Set',
season: 'Burnt Horizon'
});
The getCharms() function allows you to retrieve information about the charms available in Rainbow Six Siege. You can get all charms or filter them based on specific criteria:
name: Filter by charm namecollection: Filter by charm collectionrarity: Filter by rarity level (common, uncommon, rare, epic, legendary)availability: Filter by availability statusbundle: Filter by bundle nameseason: Filter by season releasedThe getWeapons() function allows you to retrieve information about the weapons available in Rainbow Six Siege. You can get a list of all weapons or filter them by name. Here's an example of how to use the getWeapons() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all weapons
const weapons = await r6Info.getWeapons(apiKey);
console.log('All weapons:', weapons);
// Filter weapons by name
const filteredWeaponsByName = await r6Info.getWeapons(apiKey, { name: 'F2' });
console.log('Weapons filtered by name:', filteredWeaponsByName);
} catch (error) {
console.error('Error while requesting weapons:', error.message);
}
}
main();
The getWeapons() function retrieves information about the weapons in Rainbow Six Siege. You can:
getWeapons() without any parametersname parameterThe getUniversalSkins() function allows you to retrieve information about the universal skins available in Rainbow Six Siege. You can get a list of all universal skins or filter them by name. Here's an example of how to use the getUniversalSkins() function:
const r6Info = require('r6-data.js');
async function main() {
try {
const apiKey = 'YOUR_API_KEY';
// Get all universal skins
const universalSkins = await r6Info.getUniversalSkins(apiKey);
console.log('All universal skins:', universalSkins);
// Filter universal skins by name
const filteredSkinsByName = await r6Info.getUniversalSkins(apiKey, { name: 'Black Ice' });
console.log('Universal skins filtered by name:', filteredSkinsByName);
} catch (error) {
console.error('Error while requesting universal skins:', error.message);
}
}
main();
The getUniversalSkins() function retrieves information about universal weapon skins in Rainbow Six Siege. You can:
getUniversalSkins() without any parametersThe package functions throw an exception if an error occurs during API requests. Make sure to handle errors appropriately using try-catch blocks.
If the access token has expired or is invalid, an exception will be thrown with the message "Token expired or invalid". In this case, you need to obtain a new token using the getToken() function.
This package is fan made, so it has been created for only informational purposes
FAQs
R6 (Rainbow Six Siege) API wrapper for player stats, operators, maps, ranks, seasons, charms, skins and game datas. Last Updated Y11S1
The npm package r6-data.js receives a total of 3 weekly downloads. As such, r6-data.js popularity was classified as not popular.
We found that r6-data.js demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
/Security News
Socket uncovered four malicious NuGet packages targeting ASP.NET apps, using a typosquatted dropper and localhost proxy to steal Identity data and backdoor apps.
Research
An emerging npm supply chain attack that infects repos, steals CI secrets, and targets developer AI toolchains for further compromise.
Company News
Socket is proud to join the OpenJS Foundation as a Silver Member, deepening our commitment to the long-term health and security of the JavaScript ecosystem.