The tricky part

The API at api-prod.nvidia.com requires an idtoken header -- a JWT issued by login.nvidia.com. The token expires after one hour and there is no public way to get one programmatically. No OAuth client credentials, no API key, nothing.

The solution is Playwright with a persistent browser context. The script opens the GFN account page, waits for the page to make an API call, and intercepts the token from the request headers:

def get_token_via_browser() -> str:
    from playwright.sync_api import sync_playwright

    captured_token = None

    def on_request(request):
        nonlocal captured_token
        if "api-prod.nvidia.com" in request.url and not captured_token:
            token = request.headers.get("idtoken")
            if token:
                captured_token = token

    BROWSER_DATA_DIR.mkdir(exist_ok=True)

    with sync_playwright() as p:
        context = p.chromium.launch_persistent_context(
            str(BROWSER_DATA_DIR), headless=False,
        )
        page = context.pages[0] if context.pages else context.new_page()
        page.on("request", on_request)
        page.goto(GFN_ACCOUNT_URL, wait_until="domcontentloaded")

        page.wait_for_event(
            "request",
            predicate=lambda r: (
                "api-prod.nvidia.com" in r.url
                and r.headers.get("idtoken")
            ),
            timeout=120_000,
        )
        context.close()

    return captured_token

Because the context is persisted in .browser-data/, you only need to log in once. On subsequent runs Playwright reuses the session cookies and the token gets captured without interaction.

The API

The session history endpoint is /gfn-paywall-api/api/v2/userplaytime/sessionshistory. It takes spanStartDate and spanEndDate as query parameters and returns something like this:

{
  "sessionHistory": [
    {
      "sessionStartDate": "2026-04-11T17:58:01.000Z",
      "sessionEndDate": "2026-04-11T20:59:52.000Z",
      "gameId": "100358911",
      "gameTitle": "Baldur's Gate 3",
      "totalPlaytime": 181.0
    }
  ]
}

One catch: the API only returns data within a single billing period. If your date range spans multiple months you get incomplete results. The fix is to chunk requests by calendar month:

chunk_start = start.replace(day=1)
while chunk_start < end:
    if chunk_start.month == 12:
        chunk_end = chunk_start.replace(year=chunk_start.year + 1, month=1)
    else:
        chunk_end = chunk_start.replace(month=chunk_start.month + 1)
    params["spanStartDate"] = chunk_start.strftime(...)
    params["spanEndDate"] = min(chunk_end, end).strftime(...)
    # fetch and collect
    chunk_start = chunk_end

Sessions at month boundaries can appear in both adjacent chunks, so the results need to be deduplicated.

Usage

Example output for me:

$ uv run nvidia-playtime
Opening GFN account page...
If prompted, log in with your NVIDIA account.
Token captured.

Fetching sessions: 2026-03-13 to 2026-04-12
  2026-03-01 .. 2026-04-01
  2026-04-01 .. 2026-05-01
Added 28 new sessions, 28 total in sessions.json

Date                 Game                                     Duration
----------------------------------------------------------------------
2026-03-14 18:53:35  Baldur's Gate 3                          3h 11m
2026-03-14 23:17:01  Baldur's Gate 3                          1h 34m
...
2026-04-11 17:58:01  Baldur's Gate 3                          3h 01m
----------------------------------------------------------------------
Total                                                         48h 12m

28 sessions

Running it again only appends new sessions.

What I learned

NVIDIA has a second endpoint at /userplaytime/history that takes a memberSince parameter. It sounds like it should return the full history, but it only goes back about 6 weeks and doesn't include game titles. Not useful.

Using Playwright to intercept tokens from a real browser session is a nice pattern for APIs that don't offer proper auth for scripts. This is especially relevant because of the second factor, which is an email with a link you need to open. The persistent context makes it almost seamless after the first login.

The setup

Each agent is a single function plan(snap) -> plays. snap is the info-set view (my hand, public pile tops + histories, public hand sizes, draw count) -- the same information a human gets across the table. Each agent picks an entire turn-sequence of plays at once: the planner enumerates every legal 2-card sequence the hand can make this turn, scores each summed sequence, and picks the lowest. This single trick of sequence-aware planning is worth a lot: it lets the agent set up a backwards trick (card == top ∓ 10) within its own turn -- e.g. play 60 on an UP pile, then play 50 as a -10 trick -- instead of waiting for the trick to happen by chance.

The five agents

In order of increasing cleverness:

• random -- uniform random valid sequence. Baseline.

• greedy -- score = gap: how far the play moves the pile top, with the backwards trick scoring -10. No memory.

• counting -- greedy + a memory of every card already played + a tiny tiebreaker that prefers piles where my next backwards-trick complement is still alive (in my hand > unseen > dead).

• expert -- counting + a hand-aware "leftover pain" penalty (don't strand my own worst cards), a one-turn lookahead (don't strand the next player) and an endgame DFS that, once the deck is empty, checks whether any legal order finishes the deck.

• mcts -- the one this post is about.

Results

200 games per configuration × 4 configs (2 / 3 / 4 / 5 players) = 800 games per strategy. MCTS is the slow one at ~150 s per game, so its full 800-game run takes a few hours; the heuristic batches finish in minutes. I ran the heavier batches following the same Automate Compute on Hetzner rsync / run / rsync-back pattern, just with a uv-based job.sh instead of a Docker build.

Win rates by player count (each cell is wins out of 200 games):

MCTS beats every heuristic at every player count -- by 3-6× the best-heuristic win rate -- and the absolute lift over expert peaks at 4 players (+19 pp). That was the opposite of what I expected: small hands plus a wider team should be the hardest case for any agent, but it's where actually simulating the future pays off the most.

How MCTS works here

The MCTS agent in this repo is flat Monte-Carlo with determinisation -- a single layer of rollouts, no tree. Per turn:

1. Candidates. Take the top TOP_K = 5 2-play sequences by greedy gap. This is the same enumeration the other agents do; MCTS just keeps several candidates instead of committing to one.

2. Determinise. The agent doesn't know who holds which unseen card. So for each rollout it samples a random partition of the unseen pool (cards not in my hand and not in any pile history) into the other players' hands at their public sizes, with the leftover becoming the draw deck. Each rollout uses a fresh random guess of the hidden state.

3. Roll out. Apply my candidate sequence to a Game rebuilt from that determinisation, then play the rest of the game with the counting agent as the policy for every player. Counting was picked as the rollout policy after a quick comparison: it gave 19 / 150 wins vs greedy-rollout's 13 / 150. Cheap to run and a decent simulator of the real future.

4. Score. 1.0 if that rollout won, otherwise cards_played / 98.

5. Pick. For each candidate, average the score over N_ROLLOUTS = 40 rollouts. Play the candidate with the highest average. That's 200 rollouts per turn (5 × 40).

def plan(snap):
    candidates = top_k_by_greedy(snap, k=5)
    best = None
    for seq in candidates:
        total = 0.0
        for _ in range(40):
            g = determinise(snap)         # random partition of unseen
            apply_sequence(g, seq)
            playout(g, policy=counting)   # finish the game
            total += score(g)
        mean = total / 40
        if best is None or mean > best.mean:
            best = (seq, mean)
    return best.seq

The interesting bit is that you don't need a "smart" rollout policy. Counting is a one-line heuristic with a 0.001-weight tiebreaker, yet wrapped in 40 determinised rollouts per candidate it gets from expert's 5.0 % overall to MCTS's 17.5 % -- and from 4.0 % to 23 % at 4 players. Most of the lift comes from actually simulating the future under a fixed policy, instead of trying to encode that simulation as more heuristic terms in a single-turn score.

So: rule-respecting agents can win The Game -- 13--23 % depending on player count, and 97 / 98 cards is a common almost-win.