Thanks to global chat I figured out how the total xp per level is calculated.

It took a lot of trial and error, especially since it changes formula after a player has unlocked everything (after level 54), but the current formula basically gives what https://www.warzone.com/wiki/Levels lists as the currently known total xp per level.

I'm mostly dropping this in a forum so I can just look it up next time instead of having to figure it out again.
Perhaps it will be useful for someone else too :)



Python code:

import math
LAST_UNLOCK_LEVEL = 54

def xp(level):
    x = level - 1
    base = 133410
    power = 0.05113961609486111
    multiplier = math.exp(power * x) - 1
    xp = math.floor(base * multiplier)
    return xp - xp % 100 # round down to nearest 100

def xp_corrected(level):
    if level <= LAST_UNLOCK_LEVEL:
        return xp(level)
    # else:
    levels_over_last_unlock = level - LAST_UNLOCK_LEVEL
    level_to_use = level + 5 * levels_over_last_unlock 
    correction = 500_000 * levels_over_last_unlock
    return xp(level_to_use) - correction

Edited 2025-09-05 11:26:03

Great Job JK! Excellent work

For us non-code folks out there (simplified some parts for the maths):

Total XP needed for Level x where x≤54:

XP = (133410e^0.05113961609486111(x-1)) - 133410

round down to nearest hundred*

Total XP needed for Level x where x≥54:

XP = (13340e^0.05113961609486111(6x-271)) - 500000x + 26866590

round down to nearest hundred*

* = There are some levels where the value actually rounds up instead of rounding down.

Here are all the levels where it rounds up rather than round down. The level is given, followed by the value of the XP calculated without rounding.


2: 6999.99932028
21: 237596.437826
26: 237596.437826
38: 751594.64068
55: 2092791.26946
64: 38006494.7456
67: 101672694.895

As you can see, these values are all very close to rounding up, all within 10 points of the following hundred. My hypothesis is that the XP number rounds up if the calculated number is within 10 of the next higher hundred, and that it rounds down otherwise.

Level 28 has a calculated value of 397289.913983, and it rounds down. This is the highest value I could find for the distance between a calculated XP and the hundred multiple below, for which it rounded down. So this is consistent with my hypothesis.

Edited 2025-09-05 03:00:31

Values for total XP as calculated with formula

70: 263,777,500
71: 360,926,300 (this one rounds up)
72: 493,142,700
73: 673,020, 200
74: 917,675,100
75: 1,250,370,000
76: 1,702,722,100 (this one rounds up)
77: 2,317,702,500 (this one rounds up)
78: 3,153,714,400
79: 4,290,134,800
80: 5,834,846,600

If the levelup formula continued as it were before level 54, I would be level 106 now. And the top leveled player would be level 145.
Not sure why Fizzer wouldn't have it like that. Maybe I'll ask that in next AMA.

Edited 2025-09-05 03:24:26

Looking back at this forum now, I should note that the graph shows the XP required to level up from L-1 to L; so it is not the cumulative XP.

EDIT:



And for everyone that doesn't understand how log plots work:



EDIT 2:
I need to leave the code somewhere, so here goes nothing:

### Plot graphs for the XP function ###
import matplotlib.pyplot as plt

# Calculate cumulative XP from level 1 to 75
level_limit = 76
levels = list(range(1, level_limit))
cumulative_xp = []
xp_per_level = []

for level in levels:
        xp_value = xp_corrected(level)
        xp_per_level.append(xp_value)
        cumulative_xp.append(sum(xp_per_level))


# Plot the graph
plt.figure(figsize=(10, 6))
plt.plot(levels, cumulative_xp, marker='o', linestyle=':', color='blue', label='Cumulative XP')
plt.plot(levels, xp_per_level, marker='s', linestyle='-', color='red', label='XP per Level')
plt.yscale('log')
plt.title('Logarithmic graph of xp required')
plt.xlabel('Level')
plt.ylabel('XP')
plt.legend()
plt.xticks(range(0, level_limit, 5), minor=False)
plt.xticks(range(0, level_limit), minor=True)
plt.grid(which='minor', linestyle='-', linewidth=0.5, color='lightgray')
plt.grid(which='major', linestyle='-', linewidth=1, color='gray')
plt.show()

# Plot it linear too
plt.figure(figsize=(10, 6))
plt.plot(levels, cumulative_xp, marker='o', linestyle=':', color='blue', label='Cumulative XP')
plt.plot(levels, xp_per_level, marker='s', linestyle='-', color='red', label='XP per Level')
plt.title('Linear graph of xp required')
plt.ticklabel_format(axis='y', useOffset=False, style='plain')
plt.xlabel('Level')
plt.ylabel('XP')
plt.legend()
plt.xticks(range(0, level_limit, 5), minor=False)
plt.xticks(range(0, level_limit), minor=True)
max_xp = max(cumulative_xp)
major_y_step = max_xp // 10
minor_y_step = major_y_step // 5
major_y_ticks = list(range(0, max_xp + 1, major_y_step))
plt.yticks(major_y_ticks, [f"{x:_}" for x in major_y_ticks], minor=False)
plt.yticks(range(0, max_xp, minor_y_step), minor=True)
plt.grid(which='minor', linestyle='-', linewidth=0.5, color='lightgray')
plt.grid(which='major', linestyle='-', linewidth=1, color='gray')
plt.show()

Edited 2025-09-22 10:55:36

Great work ! thanks all !