What Rank Is Jynxzi in R6? 12 Steps, 45 Min [2026]

Type “what rank is jynxzi in r6” into Google on any given week and you’ll get a different answer than you would have gotten the week before. That’s not a bug in the search results. Rainbow Six Siege ranks move after every single match now, and Jynxzi (real name Nicholas Stewart) plays enough ranked Siege on stream that his tier can shift two or three times before a video even finishes uploading. Rather than hand you a number that’s stale by the time you read it, this tutorial shows you how to pull his current rank yourself, using the same official page, trackers, and APIs that esports data sites use, step by step.

By the end you’ll have a working Python script that looks up any Ubisoft account’s rank on demand, not just Jynxzi’s, plus a clear read on why three different trackers can show you three different numbers for the same player on the same day. Twelve steps, roughly 45 minutes if you’re following along and typing the code yourself. If you’d rather skim the broader esports rank and stats coverage on this site first, that’s a fine place to start too.

Why “What Rank Is Jynxzi in R6” Keeps Trending

Jynxzi built his audience on Rainbow Six Siege, and his rank has become part of the show. He streams ranked grinds for hours, reacts live when a game pushes him up or down a division, and his Twitch following (11.3 million as of September 12, 2026) means every rank swing gets clipped and reposted within minutes. That turns a personal stat into a recurring search query.

The moment that really cemented the search habit happened when a loss dropped him straight out of Champion. On stream he said he was “absolutely f**king livid” and warned his chat he was “going to be caught in Diamond for the rest of my life” if the team lost the next game, adding that he hadn’t lost Champion in years. That clip spread fast, and it left a lot of viewers wondering whether he clawed his way back or stayed stuck in Diamond. Fan rank-check compilations circulating on TikTok in mid-October 2026 placed him around Emerald 1, which tells you how much ranked Siege can move a player in either direction across a season. None of that is something a single cached screenshot can answer reliably, which is exactly the problem this tutorial solves.

There’s also a structural reason the question is confusing right now. Rainbow Six Siege shipped a full overhaul of its ranked system this year, and most of the rank explainers floating around the internet still describe the old system. If you’re checking a rank against outdated tier names or RP math, you’ll get the wrong read even with accurate raw data. So before touching any tool or API, it’s worth getting the current system straight.

Rainbow Six Siege Ranked 3.0, Explained

Ubisoft calls the current structure Ranked 3.0, and it landed earlier in Year 11 of Siege’s live service. The headline change is that hidden MMR is gone. For years, your visible rank and your actual matchmaking skill rating were two separate numbers, and the real one stayed hidden from players. Under Ranked 3.0, your Rank Points, or RP, are the only number that matters: it’s what you see on your profile, and it’s what the matchmaker uses to find your next lobby. Ubisoft’s own help documentation puts it plainly, describing rank as the measure of “your in-game skills and progression in Ranked mode.”

There are eight tiers, each split into five divisions numbered V (lowest) through I (highest), except at the very top (our full breakdown of all 40 R6 Siege ranks covers the division structure in more depth if you want the complete ladder). That’s where Siege differs from most ranked shooters: instead of one flat Champion bucket, Champion itself now carries its own set of divisions on a lot of trackers, and above all of that sits a separate, invite-only leaderboard called the Legend Division, which we’ll get to later in this piece.

RP moves after every ranked match based on the result and the strength of the lobby you played in. Ubisoft is intentionally vague about the exact formula, but confirms the basic mechanic directly: “The MMR is updated solely on the outcome of your match,” which under Ranked 3.0 translates into RP gains or losses immediately reflected on your profile, not a delayed recalculation. Third-party trackers report gains and losses typically landing somewhere between 20 and 80 RP per match, with bigger swings for lopsided lobbies and smaller ones for closely matched games.

Here’s the RP breakdown as reported across current trackers for the lower and middle tiers, where the numbers are consistent enough to trust:

Tier	Approximate RP range	Divisions
Copper	0 – 1,599	V to I
Bronze	1,600 – 2,099	V to I
Silver	2,100 – 2,599	V to I
Gold	2,600 – 3,199	V to I
Platinum	3,200 – 4,099	V to I
Emerald	4,100 – 4,999	V to I
Diamond	5,000 and up	V to I (boundary with Champion varies by tracker)
Champion	Top of the ladder, performance-gated	Varies by tracker

Notice that last row’s caveat. Ubisoft has not published an authoritative, division-by-division RP table for Diamond and Champion, and the third-party sites that try to reverse-engineer it disagree with each other by a few hundred RP in places. That’s not sloppy research on their part, it’s just a genuinely unpublished boundary. It’s also the single biggest reason you should never rely on a static rank table (including this one) to answer “what rank is this player right now.” A table tells you roughly how the ladder is shaped. Only a live lookup tells you where someone actually sits on it today.

Placement works the same way for everyone, streamer or not. Ubisoft’s support documentation confirms that your first five ranked matches of a new season set your starting point, rather than dropping you back to zero the way some older competitive shooters do. After that, every win or loss adjusts your RP individually, so a player’s rank is really a running total built match by match rather than a score that gets recalculated in bulk overnight. That’s part of why a lookup done at 9 a.m. and another done at 9 p.m. on the same player can genuinely disagree: five or six ranked games in between is enough to shift a division, sometimes a full tier.

Who Jynxzi Is, and Why His Rank Never Sits Still

Nicholas Stewart, 25, started streaming on Twitch back in January 2019 and didn’t break out until years later, when short-form Siege clips turned him into one of the platform’s fastest-growing creators. He joined Spacestation Gaming as a content creator on March 31, 2023, crossed a million Twitch followers less than two weeks later, and has since built a YouTube channel with 6.9 million subscribers and 2.7 billion total views. He picked up Best Breakthrough Streamer and Gamer of the Year at the 2023 Streamer Awards, then Best FPS Streamer in 2024, and he’s branched out into other games (Fortnite, and Clash Royale since April 2025) without ever dropping Siege as his core content.

None of that biography answers the rank question, and that’s the point: popularity and ranked skill move on separate tracks. A streamer with millions of followers can still lose a Champion placement to a bad duo queue session, exactly like the meltdown clip above. What matters for this tutorial is that Jynxzi plays enough ranked volume, on a public account, that his profile makes a good test case for learning to look up anyone’s rank, not because he’s uniquely hard to track, but because his rank actually changes often enough to prove whether your lookup method works in real time.

One more wrinkle worth flagging before you start: high-profile accounts sometimes stream from alternate or practice accounts, and a rank check against the wrong Ubisoft ID will give you a confidently wrong answer. Step 1 below deals with that directly.

It’s also worth being clear about who actually wants this information and why, since it shapes how much precision you need. A casual viewer settling a chat argument just wants a tier name. Someone running a community prediction thread or a fantasy-style pick’em around content creators wants an actual RP number with a timestamp, since small shifts matter for bragging rights. A developer building a Discord bot for a Siege community server wants a stable, scriptable method rather than a one-time manual check. The twelve steps below cover all three cases, starting with the manual methods anyone can do in a browser and ending with the scripted approach that scales.

Prerequisites for This Tutorial

You don’t need to own Rainbow Six Siege to follow this, since every lookup method here reads public profile data rather than anything behind a game client. Here’s what to have ready:

• A modern browser, for the manual checks in Steps 2 through 4
• Python 3.10 or newer installed and on your PATH
• pip, for installing the requests library (any recent 2.x release works)
• A terminal or command prompt
• Optional: curl and jq for the troubleshooting section, useful for testing an endpoint without writing Python
• Optional: a free Ubisoft account, only needed if you want to check your own profile’s extended stats rather than someone else’s public one

Confirm Python is ready before moving on:

python3 --version
pip install requests

If that second command errors out, make sure pip is on your PATH or substitute python3 -m pip install requests, which works even when the standalone pip command doesn’t.

Step 1: Lock Down the Exact Account You’re Checking

Every method below is only as good as the username and platform you feed it. For Jynxzi specifically, that means using the handle he actually streams from, on the platform he plays on (PC, listed as “uplay” in most of these tools’ platform codes, versus “psn” for PlayStation or “xbl” for Xbox). Streamers occasionally play from secondary or practice accounts, and a rank pulled from the wrong one will look completely plausible while being completely wrong.

Before you query anything, write down three things: the exact in-game name, the platform, and the date you’re checking. Ranks move fast enough under Ranked 3.0 that “checked it yesterday” and “checked it today” can be genuinely different answers, and having a timestamp attached to your result is what separates a useful rank check from a screenshot someone’s going to dispute in the comments six weeks later.

Step 2: Read Ubisoft’s Own Stats Page First

Start with the source that can’t be stale or scraped wrong, because it’s the actual data. Ubisoft runs an official Rainbow Six Siege stats and rank page under its own domain, reachable through ubisoft.com’s game hub for Siege. It shows your own account’s rank, RP, and ranked history directly from Ubisoft’s servers, and lets you compare against friends on your platform.

The catch is that it’s built around your own logged-in account, not arbitrary lookups of other players. It’s the right tool if you’re checking your own rank, or if you want to confirm what a trusted source’s own UI calls their rank. For Jynxzi’s rank or anyone else’s public profile, you’ll lean on the next three tools instead, treating this page as your ground truth for how Ubisoft itself defines the system (which is also where the official rank description quoted earlier comes from). If you want a deeper walkthrough of setting up your own stats dashboard rather than one-off lookups, our Siege stats tracker setup guide covers that separately.

Step 3: Cross-Check R6 Tracker Network

Tracker Network runs one of the most widely used third-party Siege stat sites. Search a player’s Ubisoft username or platform ID, and you land on a profile page showing current-season rank, RP, match history, K/D, win rate, operator usage, and map stats, all pulled from publicly available Ubisoft game data rather than anything requiring the player’s cooperation.

Two things to watch for here. First, Tracker Network, like every scraper-based tool, only refreshes a profile when someone actually requests it, so a profile nobody has looked up in a while can show a stale rank until your visit triggers a refresh. Second, name changes trip these tools up constantly: if a player switched their display name recently, you may need to search by platform ID instead of the current name to land on the right profile. Treat whatever number you get here as a second opinion to weigh against Step 2, not a final answer on its own.

Step 4: Cross-Check R6Tab and Arenyze

The next layer is the pair of tools this tutorial’s scripting steps are built around: R6 Arenyze and the R6Tab project. Both expose player stats and ranks through unofficial REST APIs, meaning you can query them from code instead of clicking through a web UI every time. Arenyze pairs its API with a Node/TypeScript wrapper for developers who want ranks inside their own apps or Discord bots, while R6Tab’s API (hosted at apitab.com) is the one we’ll call directly in Steps 6 through 9.

A separate site, buyboosting.com’s rank guide, is worth bookmarking too, not as a lookup tool but as a reference for the current tier names and division structure, since it’s kept reasonably current with each Ranked 3.0 patch. And for a broader rundown of what each tracker actually measures and how they differ under the hood, this comparison of Siege tracker tools is a useful read before you commit to one as your main source.

Tool	Data source	What you need to query it	Best for
Ubisoft stats page	First-party, direct from Ubisoft	Your own login (not arbitrary players)	Checking your own rank with zero ambiguity
Tracker Network	Scraped public Ubisoft profile data	Username or platform ID	Full match history and deep stats on any player
R6Tab (apitab.com)	Unofficial REST API	Username + platform code	Scripting and automated lookups
R6 Arenyze	Unofficial REST API + JS/TS wrapper	Username or Ubisoft ID	Building the lookup into a Node or TypeScript app

None of these four tools will agree with each other down to the exact RP every single time, for the reasons covered in Step 10. Running the same name through two or three of them before you report a number is the whole trick.

Step 5: Set Up Python for Automated Lookups

Clicking through four websites every time you want a rank check gets old fast, especially if you’re monitoring a rank over days or weeks rather than checking once. The rest of this tutorial builds a small, reusable Python tool against R6Tab’s API, since it’s a documented, script-friendly REST interface with no authentication step to fight through.

Create a project folder and a virtual environment so this doesn’t pollute your system Python install:

mkdir r6-rank-lookup
cd r6-rank-lookup
python3 -m venv venv
source venv/bin/activate   # on Windows: venv\Scripts\activate
pip install requests

You should see (venv) appear at the start of your terminal prompt once the environment is active. That confirms you’re installing packages into this project’s isolated environment, not globally.

Step 6: Query the R6Tab Search Endpoint

R6Tab’s API exposes a search endpoint at https://r6.apitab.com/search/{platform}/{name}, where platform is one of uplay, psn, or xbl, and name is the URL-encoded in-game handle. The response tells you whether a match was found and returns the player’s Ubisoft-assigned ID, which you need for the next step.

Create a file called search_player.py:

import requests
import time
import sys

def search_player(platform, name):
    url = f"https://r6.apitab.com/search/{platform}/{name}"
    params = {"u": int(time.time())}  # cache-busting timestamp
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    platform = sys.argv[1] if len(sys.argv) > 1 else "uplay"
    name = sys.argv[2] if len(sys.argv) > 2 else "ExampleHandle"
    data = search_player(platform, name)
    print(data)

Run it with the platform and handle you want to check:

python3 search_player.py uplay SomeHandle

A successful lookup returns something shaped like this (field names per R6Tab’s documentation; values below are illustrative, not a live pull):

{
  "status": 200,
  "foundmatch": true,
  "requested": "SomeHandle",
  "players": {
    "9bd44bde-9c48-48ae-9c2b-4e11e4b16083": {
      "p_id": "9bd44bde-9c48-48ae-9c2b-4e11e4b16083",
      "p_user": "SomeHandle",
      "p_platform": "uplay",
      "verified": true
    }
  }
}

The key you want out of this is p_id. Copy it, since Step 7 uses it to pull the actual rank data.

Step 7: Pull Full Player Data by Ubisoft ID

With a confirmed p_id in hand, the player endpoint at https://r6.apitab.com/player/{p_id} returns the full stats payload: level, current name, platform, verification status, and ranked data for the current season. Add this to a new file, get_player.py:

import requests
import time
import sys

def get_player(p_id):
    url = f"https://r6.apitab.com/player/{p_id}"
    params = {"u": int(time.time())}
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    p_id = sys.argv[1]
    data = get_player(p_id)
    print(data)

Run it against the ID you copied from Step 6:

python3 get_player.py 9bd44bde-9c48-48ae-9c2b-4e11e4b16083

You’ll get back a larger JSON object than the search call. Somewhere in that payload is the ranked block with the player’s current rank name, RP, and season identifier. The exact key names can shift between API versions, which is precisely why Step 8 walks through parsing it defensively instead of assuming a fixed structure.

Step 8: Parse Rank, RP, and Division From the Response

Raw JSON isn’t a rank. You want a short, human-readable line like “Diamond III, 5,180 RP, Y11S3,” and that means writing a small parser that doesn’t fall over the moment a field is missing, which happens more often than you’d like with unofficial APIs. Add this helper to a new file, parse_rank.py:

def extract_rank(player_payload):
    """
    Pulls rank, RP, and season out of an R6Tab player payload.
    Falls back gracefully if a field is missing, rather than crashing.
    """
    ranked = player_payload.get("ranked") or player_payload.get("stats", {}).get("ranked")
    if not ranked:
        return {"rank": "unknown", "rp": None, "season": "unknown"}

    rank_name = ranked.get("rank") or ranked.get("rank_text") or "unknown"
    rp = ranked.get("rp") or ranked.get("mmr") or None
    season = ranked.get("season") or ranked.get("season_name") or "unknown"

    return {"rank": rank_name, "rp": rp, "season": season}

if __name__ == "__main__":
    import json
    sample = {"ranked": {"rank": "Diamond III", "rp": 5180, "season": "Y11S3"}}
    print(json.dumps(extract_rank(sample), indent=2))

Running that file directly prints a clean, predictable object no matter how the upstream API names its fields that week. That defensiveness matters more than it sounds like it should. Unofficial APIs built by small community teams change their response shape occasionally without a changelog, and a script that assumes one exact structure will fail silently or loudly the next time that happens.

Step 9: Build a Reusable Rank-Lookup CLI Tool

Now combine Steps 6 through 8 into a single command-line tool you can point at any player, any time. This is the complete working project for this tutorial, save it as rank_lookup.py:

import argparse
import requests
import time
import sys

BASE_URL = "https://r6.apitab.com"

def search_player(platform, name):
    url = f"{BASE_URL}/search/{platform}/{name}"
    r = requests.get(url, params={"u": int(time.time())}, timeout=10)
    r.raise_for_status()
    return r.json()

def get_player(p_id):
    url = f"{BASE_URL}/player/{p_id}"
    r = requests.get(url, params={"u": int(time.time())}, timeout=10)
    r.raise_for_status()
    return r.json()

def extract_rank(player_payload):
    ranked = player_payload.get("ranked") or player_payload.get("stats", {}).get("ranked")
    if not ranked:
        return {"rank": "unknown", "rp": None, "season": "unknown"}
    return {
        "rank": ranked.get("rank") or ranked.get("rank_text") or "unknown",
        "rp": ranked.get("rp") or ranked.get("mmr") or None,
        "season": ranked.get("season") or ranked.get("season_name") or "unknown",
    }

def main():
    parser = argparse.ArgumentParser(description="Look up a Rainbow Six Siege player's current rank.")
    parser.add_argument("platform", choices=["uplay", "psn", "xbl"], help="uplay=PC, psn=PlayStation, xbl=Xbox")
    parser.add_argument("name", help="exact in-game handle")
    args = parser.parse_args()

    found = search_player(args.platform, args.name)
    if not found.get("foundmatch"):
        print(f"No match found for '{args.name}' on {args.platform}. Check spelling and platform code.")
        sys.exit(1)

    players = found.get("players", {})
    p_id = next(iter(players))
    full_data = get_player(p_id)
    rank_info = extract_rank(full_data)

    print(f"Player: {args.name} ({args.platform})")
    print(f"Rank:   {rank_info['rank']}")
    print(f"RP:     {rank_info['rp']}")
    print(f"Season: {rank_info['season']}")

if __name__ == "__main__":
    main()

Run it like this:

python3 rank_lookup.py uplay SomeHandle

Sample output (illustrative, since the real number depends entirely on who you run this against and when):

Player: SomeHandle (uplay)
Rank:   Diamond III
RP:     5180
Season: Y11S3

That’s the entire project: one command, any public handle on any platform, a clean rank readout. From here you can extend it with a CSV log, a Discord webhook, or a cron job. If you want to take that further into a persistent, always-on tracker rather than a one-off lookup tool, our guide to building a full Jynxzi rank tracker picks up roughly where this project leaves off.

Step 10: Handle Caching, Rate Limits, and Refresh Windows

R6Tab’s documentation notes that a profile needs roughly 1,800 seconds (30 minutes) to pass before it refreshes again, which protects their servers from being hammered but also means rapid repeated checks on the same player can return the same cached number even after a match finished. The u parameter (a Unix timestamp) in the code above is meant to bust client-side caching on your end, but it doesn’t force the upstream data to re-scrape faster than that 30-minute window.

Practically, that means if you want a truly live number right after watching someone finish a ranked match, your best bet is still the manual check in Steps 2 or 3, since those pull more directly from a live profile view. The API approach in Steps 6 through 9 is built for periodic checks (once an hour, once a day) rather than second-by-second monitoring, and treating it that way will save you a lot of confusion about why the number “isn’t updating.”

There’s no published hard rate limit on the R6Tab API beyond that refresh cooldown, but it’s an unofficial, community-run service with no SLA. Be a reasonable citizen: space out requests, cache results locally in your own script, and don’t hit it in a tight loop.

Step 11: Reconcile Conflicting Numbers Between Trackers

Run the same player through Tracker Network, R6Tab, and Arenyze back to back, and you’ll sometimes get three slightly different RP numbers, even on the same day. That’s not necessarily a bug in any of them. A few things drive the gap:

• Each tool caches on its own schedule, so the one you checked five minutes after a match often reads lower or higher than one checked right before it
• A match played between two checks moves the real number out from under you
• Tools disagree on exactly where Diamond ends and Champion begins, since (as covered earlier) Ubisoft hasn’t published that boundary
• Squad-based RP adjustments can briefly show different numbers to different viewers depending on when each tool’s backend processed that match

The fix isn’t picking one tool and trusting it blindly. It’s running at least two, noting the timestamp of each check, and reporting a range or a “as of [time]” qualifier rather than a single hard number, especially for an account like Jynxzi’s that plays enough volume to move tiers within a single stream. If a visible rank still looks ambiguous after cross-checking, our piece on estimating hidden MMR from match data walks through a statistical approach for filling that gap.

Step 12: Check Legend Division and Regional Leaderboards

If a rank check comes back Champion, that’s not necessarily the ceiling anymore. Ranked 3.0 added a Legend Division sitting above Champion, which opened mid-season with Operation Split Fire on September 1, 2026 (Year 11 Season 3). Qualifying isn’t automatic: it requires being Champion in the current season, having finished Platinum or higher the previous season, maintaining a clean reputation standing, running full account-security verification on PC, and queueing solo rather than in a premade squad, with your region locked for the season once you opt in.

Legend Division replaces the old top-end leaderboard with regional rankings visible to every player, dynamic banners showing live standing, and a cosmetic charm awarded the following season to anyone who finishes in the top 100, a charm that’s lost again if they drop out of that bracket later. If your rank check shows Champion for a high-volume player, it’s worth also checking the regional leaderboard directly to see whether they’ve cleared into Legend Division territory, since that’s a materially different claim than “Champion” alone.

Common Pitfalls When Checking Someone Else’s Rank

A handful of mistakes account for most of the wrong answers people post online about a streamer’s or pro player’s current rank:

• Checking the wrong account. Smurfs, practice accounts, and name changes all point you at data that isn’t the main profile.
• Assuming hidden MMR still exists. Pre-Ranked 3.0 explainers describe a system where your visible rank lagged behind a hidden true skill rating. That mechanic is gone. RP is both the display number and the matchmaking number now.
• Trusting one cached result as gospel. A single tracker screenshot, especially an old one being recirculated, is a snapshot, not a live state.
• Using stale Year 9 or Year 10 RP thresholds. Plenty of old guides never got updated after Ranked 3.0 reshuffled the tier boundaries, and they’ll still rank well in search.
• Forgetting to URL-encode special characters in a handle. Names with spaces, periods, or symbols need proper encoding or the search endpoint simply won’t find them.
• Mixing up platform codes. Querying xbl for a PC player (who should be uplay) returns no match, which looks identical to a typo in the name.
• Hammering an unofficial API in a tight loop. Beyond being inconsiderate to a free community-run service, it won’t even get you fresher data, since the cache window is fixed regardless of how often you ask.

Troubleshooting Guide

Here’s what to do when the lookup doesn’t behave the way the tutorial above suggests it should:

Symptom	Likely cause	Fix
"foundmatch": false	Wrong platform code, misspelled name, or unencoded special characters	Double-check the exact handle and platform; try the search manually on Tracker Network to confirm spelling first
Tracker Network shows “no data”	Profile has never been looked up before, so it hasn’t cached anything	Wait a moment after the first search and reload; the first visit often triggers the scrape
Rank field present but RP is null	Player hasn’t played a ranked match yet this season, or the field name shifted upstream	Check the raw JSON directly; confirm the player has completed placement matches this season
Different RP across two tools, same minute	Caching offsets and unpublished Diamond/Champion boundary differences	Report a range with timestamps instead of one number; see Step 11
API returns the same number as an hour ago	Inside the ~1,800-second refresh cooldown	Wait out the cooldown or use Step 2/3’s live page for an immediate read
Script throws a connection timeout	Unofficial API is temporarily overloaded or down	Retry after a short delay; add a try/except with backoff for scripts that run unattended
JSONDecodeError in Python	The endpoint returned an HTML error page instead of JSON (often a rate-limit or maintenance page)	Print response.text before calling .json() to see what actually came back
Search works but player endpoint 404s	Copied the wrong UUID, or extra whitespace got pasted in	Re-copy the p_id directly from the search response, don’t retype it by hand
Legend Division shows no entry for a known Champion player	They haven’t opted in, don’t meet the previous-season Platinum+ requirement, or aren’t in the top 100 of their region	Treat Legend Division as a separate, opt-in leaderboard, not an automatic extension of Champion

If you want a quick sanity check outside Python entirely, curl and jq will show you the raw response without any parsing logic in the way:

curl -s "https://r6.apitab.com/search/uplay/SomeHandle?u=$(date +%s)" | jq .

That command is often the fastest way to confirm whether a problem is in your Python code or in the upstream data itself, since it cuts your own parsing logic out of the loop entirely.

Advanced Tips: Tracking Rank Drift Over a Season

Once the single-shot lookup works reliably, a few small upgrades turn it into something closer to a season-long log rather than a one-off answer:

1. Append each run’s output (name, rank, RP, timestamp) to a CSV file instead of just printing it, so you can plot drift over the course of a season
2. Run the script on a schedule, but respect the roughly 30-minute cache window from Step 10, since checking more often than that just wastes requests for identical data
3. Store the previous result and diff it against the new one, so your log only grows when something actually changed, rather than accumulating duplicate rows
4. If you’re tracking multiple players at once, batch the search calls but stagger them slightly rather than firing them all in parallel against a free, unofficial API

Here’s the CSV logging piece in practice, a small addition to rank_lookup.py that turns a one-off answer into a running history file:

import csv
import os
from datetime import datetime, timezone

def log_rank(name, platform, rank_info, filename="rank_history.csv"):
    file_exists = os.path.isfile(filename)
    with open(filename, "a", newline="") as f:
        writer = csv.writer(f)
        if not file_exists:
            writer.writerow(["timestamp", "name", "platform", "rank", "rp", "season"])
        writer.writerow([
            datetime.now(timezone.utc).isoformat(),
            name,
            platform,
            rank_info["rank"],
            rank_info["rp"],
            rank_info["season"],
        ])

Call log_rank(args.name, args.platform, rank_info) right after the print statements in main(), and every run appends one row. Point a cron job or Task Scheduler entry at the script once an hour, and after a week you’ll have a real dataset showing exactly when a player crossed into a new division rather than a vague “I think it was sometime last Tuesday.”

None of that requires new tools, just the same four functions from Step 9 wrapped in a loop and a file write. It’s also worth remembering that this entire workflow is read-only and uses public profile data the same way a browser visiting those tracker sites would. It doesn’t touch anyone’s account, doesn’t require their cooperation, and doesn’t bypass anything Ubisoft or these tracker sites haven’t already made publicly queryable.

Is Looking Up Someone’s Rank Against the Rules?

Short answer: no, not for anything covered in this tutorial. Every method here reads data a player already made visible, either on their own public Ubisoft profile or through a tracker site that Ubisoft tolerates operating against that same public data. You’re not logging into anyone’s account, bypassing a login wall, or touching data that requires the player’s credentials. That’s a meaningfully different category of activity from, say, scraping private account details or automating actions inside someone else’s account, both of which would violate Ubisoft’s terms and potentially trigger a ban.

Where it does get more serious is on the player’s side of the equation, which is why Legend Division (Step 12) leans so heavily on account security. Opting into that leaderboard requires full account-security verification, including two-factor authentication on PC. That requirement exists because a public leaderboard spot makes an account a more attractive target, and Ubisoft is explicitly trading leaderboard visibility for a harder account-security bar. If you’re a streamer or a competitive player reading this rather than someone just curious about a creator’s rank, that’s the practical takeaway: the more visible your rank becomes, the more worth it becomes to lock the account behind 2FA rather than a password alone.

For your own scripts, stay on the polite side of automated access too. Nothing in this tutorial requires an API key or login, which is convenient, but it also means these are free, community-maintained services with no contractual uptime guarantee. Treat them the way you’d want your own small side project treated: reasonable request volume, real timeouts, and no tight retry loops that look like abuse from the other end of the connection. And if you’re reading this because your own Siege account got compromised rather than because you’re curious about someone else’s rank, that’s a different problem with its own fix, covered in our hacked gaming account recovery guide.

Frequently Asked Questions

What rank is Jynxzi in R6 Siege right now?

It changes often enough that any number printed here would likely be outdated by the time you read it. Fan rank-check compilations circulating in mid-October 2026 placed him around Emerald 1, after an earlier stretch this year that included a public drop out of Champion into Diamond. Run the tool built in this tutorial against his current handle for a live answer.

Did Jynxzi lose his Champion rank?

Yes, at least once this year. A loss dropped him from Champion into Diamond 1 on stream, which he reacted to live, saying he hadn’t lost Champion “in years.” Ranks under Ranked 3.0 move after every match, so a single bad session can cost a tier even for high-volume players.

What is Ranked 3.0 in Rainbow Six Siege?

It’s the current ranked system, which removed the old hidden MMR mechanic. Your Rank Points (RP) are now both your displayed rank and the number the matchmaker actually uses, across eight tiers from Copper to Champion, each with five divisions.

Is it safe to use R6Tab or Arenyze to look up a player’s rank?

Both only read publicly available Ubisoft profile data and don’t require login credentials from you or the player you’re looking up. They’re unofficial, community-built services rather than Ubisoft products, so treat their uptime and data freshness accordingly, and don’t feed them anything beyond a username or player ID.

Can I check someone’s rank without knowing their Ubisoft ID?

Yes. The search endpoint in Step 6 takes an in-game username and platform, and returns the Ubisoft ID for you. You only need the ID directly if you already have it from a previous lookup or another tool.

Why do different trackers show different RP for the same player?

Mainly caching offsets and timing. Each tool scrapes or refreshes on its own schedule, so a match played between two checks will show up on one tool before another. There’s also no published Ubisoft table for exactly where Diamond ends and Champion begins, so trackers that estimate that boundary don’t always agree.

What is the Legend Division?

A leaderboard above Champion, introduced with Operation Split Fire on September 1, 2026. It requires being Champion in the current season and Platinum or higher the previous season, plus a clean reputation record and full account verification, and it’s solo-queue only with regional leaderboards and a top-100 cosmetic reward.

How often does Ubisoft reset ranks each season?

Every new season applies a soft reset rather than wiping your rank to zero, and your first five ranked matches of the new season determine your starting placement for that season, according to Ubisoft’s own support documentation.