Xbox began testing a free, ad-supported route into cloud gaming on October 21, 2026, and the same Insider test also sells Cloud Playtime packs that start at $3.99 for 10 hours. NVIDIA still lists Free among its GeForce NOW plan names, and Amazon still gives Prime members a rotating Luna catalog at no extra cost. Free cloud gaming is having a moment. The bill just moves somewhere else.
That somewhere else is your data allowance. A cloud game is a live video stream, so every minute you play pulls a steady flow of megabytes through your router. A time cap on a free session limits minutes and says nothing about gigabytes. On a home plan with a monthly cap, in a shared flat, or on a tethered phone, the gap between those two limits decides how much free gaming you can actually afford.
This tutorial builds a small tracker that measures your own numbers instead of trusting a generic chart. In 13 steps and about 45 minutes you will write four short Python files, calibrate them on a PC, a Chromebook and a Fire TV, and finish with a report that tells you how many free sessions your monthly cap can absorb. If you are still choosing a service, read the Luna, GeForce NOW and Xbox Cloud Gaming head-to-head first, then come back to measure the one you pick.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Free Cloud Gaming Means on October 24, 2026
Before you measure anything, pin down what is actually free today. The picture shifted this month, so older guides will mislead you on at least one service.
GeForce NOW streams PC games you already own from stores that include Steam, Epic Games Store, Ubisoft Connect, Xbox PC Game Pass, GOG and EA. Its plan names are Free, Performance and a top paid tier. NVIDIA’s own page says the Install-to-Play feature is reserved for paid Performance and top-tier members, so a Free account streams games from libraries you have already linked. NVIDIA sets the session length and the queue rules for the Free plan and changes them over time. This guide could not confirm today’s values from NVIDIA’s pages, so it never hard-codes them. You will read the limit from your own account and type it into a config file in Step 3.
The service also keeps moving. On October 15, 2026, NVIDIA added DLSS 4.5 controls to the GeForce NOW app for Windows, macOS, ChromeOS and SteamOS. Call of Duty: Modern Warfare 4 arrived on the service at launch, and NVIDIA announced 25 new games for October. If you need help with accounts, our four-service free cloud gaming setup covers sign-up, and the walkthrough on linking Steam to the GeForce NOW free tier covers library linking.
Xbox is the service that changed most. Microsoft’s official Xbox pages no longer show a permanent, unrestricted free tier comparable to GeForce NOW’s. Regular cloud access ties to Game Pass, with monthly cloud allowances of 5 hours for Essential, 10 hours for Premium and 15 hours for the highest tier. The new piece is the Cloud Playtime test that opened to Xbox Insiders on October 21, 2026. It offers free play with advertisements for Insiders without Game Pass, plus paid, ad-free packs. The test is not generally available, and Xbox reportedly plans a wider rollout in November. Our walkthrough of Xbox Cloud Gaming without Game Pass tracks what the free route looks like for regular accounts.
Amazon Luna sits at the quiet end of the market. Amazon’s Fire TV pages say Prime members can play more than 25 party games at no additional cost and get a rotating selection of higher-quality games. The catalog rotates, so a game you measured last week may be gone next week. Log which catalog each title came from.
| Service | Free route today | What limits it | What your log needs |
|---|---|---|---|
| GeForce NOW | Free plan, streaming games you own | Session and queue rules set by NVIDIA (read them from your account) | Minutes per session, quality label |
| Xbox Cloud Gaming (Insider test) | Ad-supported free play, started October 21, 2026 | Test only, not generally available | Label ad-supported sessions separately |
| Xbox Cloud Gaming (Game Pass) | Included cloud hours | 5 hours (Essential), 10 hours (Premium), 15 hours (top tier) per month | Hours used, MB per minute |
| Amazon Luna | Prime members: 25+ party games plus a rotating catalog | Prime membership, rotating catalog | Which catalog the game came from |
| Xbox Cloud Playtime packs | Paid, not free (Insider test) | 10 hours for $3.99, 25 hours for $7.99, 50 hours for $11.99 (introductory prices) | Pack size, MB per minute |
Read the table as a list of things to measure. Every row ends in a number you can only get by watching your own connection, and that is the job of the rest of this guide.
Why Data Use Matters Even When the Service Is Free
A time cap and a data cap are two different fences. Free cloud gaming mostly builds the first one. Your internet provider builds the second, and the only bridge between them is a single figure: megabytes per minute. Multiply that figure by minutes and you get gigabytes. Multiply it by a session cap and you learn how many sessions fit in a month.
Three things make that figure hard to guess. First, it depends on the quality setting inside the service, the resolution your screen asks for and the frame rate. Second, it depends on the game, because busy scenes compress worse than quiet menus. Third, it depends on whether you are playing at all or sitting in a menu. A fixed number from a blog post can be wrong by a wide margin for your setup, which is why this tutorial measures instead of quoting.
The Xbox allowances make the point sharply. A Premium account has 10 cloud hours a month and the highest tier has 15, so the monthly data ceiling on those plans is simply your measured rate times those hours. A Cloud Playtime pack works the same way, because you buy hours and your connection pays in gigabytes. The table below shows the formula for each allowance. The 60 MB per minute in the last column is a placeholder rate, not a benchmark, so swap in the figure your own tracker reports.
| Allowance | Cloud time | Cost | Data at a placeholder 60 MB/min |
|---|---|---|---|
| Game Pass Essential | 5 hours per month | See Xbox for current price | 5 x 60 x 60 = 18,000 MB (18 GB) |
| Game Pass Premium | 10 hours per month | See Xbox for current price | 10 x 60 x 60 = 36,000 MB (36 GB) |
| Game Pass top tier | 15 hours per month | See Xbox for current price | 15 x 60 x 60 = 54,000 MB (54 GB) |
| Cloud Playtime pack, small | 10 hours, unused time carries over | $3.99 (introductory) | 36,000 MB (36 GB) |
| Cloud Playtime pack, medium | 25 hours, unused time carries over | $7.99 (introductory) | 90,000 MB (90 GB) |
| Cloud Playtime pack, large | 50 hours, unused time carries over | $11.99 (introductory) | Not listed |
The same arithmetic applies to a free GeForce NOW session. Once you know your rate and your session cap, the budget report in Step 10 does the multiplication for you.
Prerequisites and Versions
You need very little. The tracker is plain Python with one third-party package, and every step that touches a Chromebook or a TV uses your router instead of software on the device.
- A current Python release. The code in this guide ran on Python 3.12.3. Check yours with
python3 --version. - psutil, current release from PyPI. It reads the operating system’s network counters on Windows, macOS and Linux. The sample outputs here came from psutil 7.2.2.
- A PC, Mac or Linux machine for the first calibration. Windows 11 works as well as any Linux distribution.
- A Chromebook on current stable ChromeOS with a Google account. GeForce NOW has a ChromeOS app and also runs in the browser.
- A Fire TV Stick or a Fire TV television if you want the TV test. Amazon’s official specification page lists the Fire TV Stick 4K (3rd Gen, 2026) with dual-band Wi-Fi 6, which is plenty for streaming.
- Your router’s admin login. You will read a per-device traffic counter before and after each test.
- Your internet provider’s monthly cap and your usage so far. Most providers show both in an account portal or app. If your plan has no cap, the tracker still works as a bandwidth diary.
- One free account per service you want to test. A free GeForce NOW account, a Microsoft account and an Amazon account with Prime are enough.
A little setup hygiene pays off later. Keep the project folder somewhere you back up, because the CSV ledger is the only record of your measurements and a few months of history becomes valuable once you start comparing settings. If several people in the household play, agree on one device label per person or per screen. And write your provider’s cap and today’s usage on a sticky note before you start, so Step 3 takes thirty seconds instead of ten minutes of hunting through an account portal.
Budget about ten minutes of streaming per calibration. Three devices and three services is nine short sessions, which fits inside the 45-minute estimate if you queue the PC tests first.
Steps 1 to 3: Plan the Test, Create the Project, Write the Config
Step 1: Decide your test matrix. Write down every pairing you expect to use. A sensible starter matrix is a PC on GeForce NOW Free, a Chromebook on GeForce NOW Free and a Fire TV on Xbox Cloud Gaming or Luna. Add a fourth row for any service you only try occasionally. Each row gets a device label, a service label and a quality label, and you will reuse those exact words in every log entry. Consistent labels are what make the report trustworthy. A typo such as geforcenow-free in one row and geforce-now-free in another splits one service into two groups and halves the data behind each average.
Pick short, lowercase labels with hyphens and no spaces. Good device labels are pc, chromebook, firetv and phone. Good service labels are geforce-now-free, xbox-cloud and luna. For quality, use the actual name of the setting you picked in the service, or a plain description such as default when the service offers no choice. If the setting names change after an app update, add a date suffix to the new label so old and new rows never merge.
Step 2: Create the project folder and a virtual environment. On macOS or Linux, open a terminal and run:
mkdir cloudmeter && cd cloudmeter
python3 -m venv .venv
source .venv/bin/activate
pip install psutilOn Windows, use PowerShell instead:
mkdir cloudmeter; cd cloudmeter
py -m venv .venv
.venv\Scripts\Activate.ps1
pip install psutilExpect the prompt to gain a (.venv) prefix. If PowerShell refuses to run the activation script, the troubleshooting section has the one-line fix.
Step 3: Write the config file. Create plan.json in the project folder. It holds the four numbers the budget report needs.
{
"monthly_cap_gb": 1000,
"other_usage_gb_this_month": 412,
"session_cap_minutes": 60,
"alert_percent": [80, 95]
}Replace every value with your own. monthly_cap_gb is your provider’s cap. other_usage_gb_this_month is everything else your household has used so far, which you update from the provider portal whenever you run a report. session_cap_minutes is the free session length shown on your own account, not a number to copy from a blog. alert_percent sets the two warning levels. The values above are placeholders for a 1,000 GB plan.
To find your provider’s numbers, look for a usage meter in the provider’s app or web portal. Some providers show usage by day, which makes it easy to read off the month so far. Others show only a rolling total. Either works, as long as you copy the figure in gigabytes and note the date you copied it. If your plan is uncapped, set a cap that matches your own comfort level, since a household budget is still useful when the provider imposes none.
Step 4: Build the PC Meter Script
The PC meter reads the operating system’s byte counters once a second, watches them for the length of a session and writes one row to a CSV file. It needs two files. The first, ledger.py, is a tiny shared module that every other script imports for loading the plan and appending rows.
import csv
import json
from datetime import datetime
from pathlib import Path
LOG = Path("sessions.csv")
FIELDS = ["start", "device", "service", "quality", "minutes",
"mb_down", "mb_up", "peak_mbps", "method"]
def load_plan(path="plan.json"):
with open(path, encoding="utf-8") as f:
return json.load(f)
def append(row):
is_new = not LOG.exists()
with LOG.open("a", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=FIELDS)
if is_new:
writer.writeheader()
writer.writerow({k: row.get(k, "") for k in FIELDS})
def read_all():
if not LOG.exists():
return []
with LOG.open(newline="", encoding="utf-8") as f:
return list(csv.DictReader(f))
def now_iso():
return datetime.now().isoformat(timespec="seconds")The second file, meter.py, does the watching. It accepts a device label, a service label, a quality label and an optional interface name. A --minutes flag stops it automatically, which is useful when you are busy playing.
import argparse
import signal
import sys
import time
import psutil
import ledger
def read_counters(nic):
if nic:
stats = psutil.net_io_counters(pernic=True).get(nic)
if stats is None:
sys.exit(f"Interface '{nic}' not found. Run: python meter.py --list")
return stats.bytes_recv, stats.bytes_sent
stats = psutil.net_io_counters()
return stats.bytes_recv, stats.bytes_sent
def main():
p = argparse.ArgumentParser(description="Meter network use during a cloud gaming session")
p.add_argument("--list", action="store_true", help="list network interfaces and exit")
p.add_argument("--device", default="pc")
p.add_argument("--service")
p.add_argument("--quality", default="default")
p.add_argument("--nic", help="interface name, for example Wi-Fi, en0 or wlan0")
p.add_argument("--minutes", type=float, default=0, help="stop automatically after N minutes")
a = p.parse_args()
if a.list:
for name, stats in psutil.net_io_counters(pernic=True).items():
print(f"{name:<20} down {stats.bytes_recv / 1e6:>10.1f} MB")
return
if not a.service:
p.error("--service is required")
stop = False
def handle_sigint(*_):
nonlocal stop
stop = True
signal.signal(signal.SIGINT, handle_sigint)
down0, up0 = read_counters(a.nic)
t0 = last_t = time.time()
last_down = down0
peak = 0.0
start = ledger.now_iso()
print("Metering. Start your game session now. Press Ctrl+C when it ends.")
while not stop:
time.sleep(1)
down, up = read_counters(a.nic)
now = time.time()
mbps = max(down - last_down, 0) * 8 / 1e6 / (now - last_t)
peak = max(peak, mbps)
last_down, last_t = down, now
elapsed = (now - t0) / 60
print(f"\r{elapsed:6.1f} min {(down - down0) / 1e6:9.1f} MB {mbps:6.1f} Mbps", end="", flush=True)
if a.minutes and elapsed >= a.minutes:
break
down, up = read_counters(a.nic)
minutes = (time.time() - t0) / 60
mb_down = (down - down0) / 1e6
mb_up = (up - up0) / 1e6
ledger.append({
"start": start, "device": a.device, "service": a.service,
"quality": a.quality, "minutes": round(minutes, 2),
"mb_down": round(mb_down, 1), "mb_up": round(mb_up, 1),
"peak_mbps": round(peak, 1), "method": "psutil",
})
print(f"\nLogged {mb_down:.0f} MB down in {minutes:.1f} min = {mb_down / minutes:.1f} MB/min")
if __name__ == "__main__":
main()Three details deserve a note. The script counts decimal megabytes, where one megabyte is one million bytes, because providers and routers lean that way and mixing units is the most common source of confusing totals. It records the highest one-second download rate as peak_mbps, a handy sanity check against your Wi-Fi limits. And it catches Ctrl+C itself, so stopping a session still writes the row instead of throwing it away.
The main loop is short. Each second it reads the cumulative received and sent byte counts, subtracts the previous reading to get the bytes moved in that second, converts to megabits per second and prints a live line. At the end it subtracts the first reading from the last to get the session total. Because the script works from differences between counter readings, it does not matter what the counters read when you started, and the machine can have been running for weeks. If a counter ever resets mid-session, the script clamps the negative jump to zero for the live display instead of crashing. The final totals can still be off after a reset, which is one more reason to keep each calibration to ten minutes.
Step 5: Add a Manual Log for Chromebook and TV
Software metering works only where Python can see the traffic. A Chromebook’s Linux container has its own virtual network card, so a script inside it would miss the traffic of the Chrome browser and the GeForce NOW app that live outside it. A Fire TV does not run your scripts at all. For both, the router is the witness. You read the device’s download counter before the session, read it again after, and hand both numbers to a second script.
import argparse
import sys
import ledger
p = argparse.ArgumentParser(description="Log a session measured with router counters")
p.add_argument("--device", required=True)
p.add_argument("--service", required=True)
p.add_argument("--quality", default="default")
p.add_argument("--minutes", type=float, required=True)
p.add_argument("--before", type=float, required=True, help="router download counter before the session")
p.add_argument("--after", type=float, required=True, help="router download counter after the session")
p.add_argument("--unit", choices=["mb", "gb"], default="mb")
a = p.parse_args()
used_mb = (a.after - a.before) * (1000 if a.unit == "gb" else 1)
if used_mb <= 0:
sys.exit("The 'after' counter must be larger than the 'before' counter.")
ledger.append({
"start": ledger.now_iso(), "device": a.device, "service": a.service,
"quality": a.quality, "minutes": a.minutes,
"mb_down": round(used_mb, 1), "method": "router",
})
print(f"Logged {used_mb:.0f} MB over {a.minutes:g} min = {used_mb / a.minutes:.1f} MB/min")The script converts the difference to megabytes, refuses nonsense such as a counter that went backwards, and appends a row tagged router so you can tell the two methods apart later. Here is the decision table for every device you are likely to test.
| Device | Best method | Accuracy | Effort |
|---|---|---|---|
| Windows PC | meter.py, or Get-NetAdapterStatistics in PowerShell | High, whole adapter | Low |
| Mac | meter.py, or netstat -I en0 -b | High, whole adapter | Low |
| Linux PC | meter.py, or the rx_bytes file under /sys/class/net | High, whole adapter | Low |
| Chromebook | Router per-device counter plus manual.py | Medium, depends on router rounding | Medium |
| Fire TV Stick or Fire TV television | Router per-device counter plus manual.py | Medium, depends on router rounding | Medium |
| Phone on Wi-Fi | Router per-device counter plus manual.py | Medium, depends on router rounding | Medium |
Whole-adapter counters include everything the machine does, so close other apps before a PC test. Router counters include everything the device does, which on a TV is mostly the stream itself.
Accuracy on the router path depends on how the router counts. Some models update the per-device figure every few seconds, others only every minute, and a few round to the nearest tenth of a gigabyte. You can test your router in two minutes. Download a file of known size on one device, read the counter before and after and compare. If the two differ by more than a few percent, treat router-based rows as rough and use longer sessions to average out the error.
Steps 6 and 7: Calibrate on a PC With a Free GeForce NOW Session
Step 6: Find your network interface. With the virtual environment active, list the interfaces and their running download totals.
python meter.py --listPick the one that carries your internet traffic. On a laptop that is usually the Wi-Fi adapter, on a desktop it is Ethernet. Names differ by system, so copy the exact text printed in the first column. If you leave --nic out, the script sums every adapter, which double-counts traffic when a VPN is running.
Step 7: Run the first calibration. Close browser tabs, cloud-sync clients, game launchers and anything else that talks to the network. Open the GeForce NOW app or its browser version, sign in with your free account and get your game to the title screen. Then start the meter in a terminal and, only once you are in the game, begin playing.
python meter.py --device pc --service geforce-now-free --quality balanced --nic Wi-Fi --minutes 10Two timing rules matter. Start the meter after any queue wait ends, because minutes spent waiting move almost no data and would drag your MB-per-minute figure down. And play the way you normally play. Walking around a quiet menu for ten minutes would understate a real session. When the ten minutes pass, the script stops and prints a summary like this one.
Metering. Start your game session now. Press Ctrl+C when it ends.
10.0 min 600.4 MB 11.8 Mbps
Logged 600 MB down in 10.0 min = 60.0 MB/minThese numbers are made up for illustration. Your totals will differ, and that difference is the whole point. Use the quality label to record whatever the app’s streaming-quality setting is called on your version, since the option names change between releases. If you want to test the DLSS 4.5 controls NVIDIA added on October 15, log them under a different quality label and compare, rather than assuming they change your data use in either direction.
Repeat the test for any other service you can run on the PC. Xbox Cloud Gaming runs through the Xbox app or the browser at xbox.com/play, and Luna runs for Prime members once you have followed our Luna free tier setup. Use a distinct service label each time, for example xbox-cloud or luna.
Choose your test game with care. Pick something you genuinely play, in a scene you can repeat. A slow turn-based title and a fast shooter produce different streams, so a single calibration game will not describe your whole library. If you play both kinds, calibrate both and give each its own quality label, for example balanced-shooter and balanced-slow. The extra ten minutes is cheap compared with budgeting a month on the wrong number.
Steps 8 and 9: Calibrate a Chromebook and a Fire TV From the Router
Step 8: The Chromebook test
Sign in to the GeForce NOW app or browser version on the Chromebook and get your game to the title screen. Our Chromebook cloud gaming setup covers the install and controller pairing, and the guide to turning an older laptop or Chromebook into a cloud gaming rig helps if your hardware is borderline. Then log in to your router’s admin page from another device and find the per-device traffic view. Many routers have one, and some hide it behind a traffic monitor switch that you must turn on first.
- Write down the Chromebook’s current download total from the router page. Note whether the unit is MB or GB.
- Start your stopwatch and play for ten minutes, skipping the queue wait and any menus.
- Read the download total again straight after you stop.
- Run the manual logger with both readings.
python manual.py --device chromebook --service geforce-now-free --quality balanced --minutes 10 --before 3120 --after 3700Logged 580 MB over 10 min = 58.0 MB/minThe readings above are invented placeholders. Your router might display gigabytes with one decimal place, in which case a ten-minute test shows a change of only a few tenths and rounding eats your accuracy. Pass --unit gb and either lengthen the test or choose a router view that shows megabytes.
Step 9: The Fire TV test
Amazon’s current Fire TV pages advertise cloud gaming through Amazon Luna and Xbox Game Pass without a console. GeForce NOW is where model differences matter. NVIDIA said on October 8, 2026 that Fire TV users would soon be able to buy memberships through Amazon, and PC Guide’s report on the Amazon subscription option describes the rollout. NVIDIA documents the Amazon purchase for Performance and the top paid tier only. Amazon’s listings, reportedly, show GeForce NOW as available on the Fire TV Stick 4K Plus and 4K Max but still marked coming soon on some other sticks, so check your exact model before you plan a test. Do not assume every smart TV works either, since the confirmed support here is for Fire TV hardware, not for every television.
The measurement routine is the same as for the Chromebook. Read the TV’s counter from the router, play a ten-minute session of whichever service your stick supports, read the counter again and log it.
python manual.py --device firetv --service xbox-cloud --quality default --minutes 10 --before 8.4 --after 9.1 --unit gbLogged 700 MB over 10 min = 70.0 MB/minFor a Samsung television, a single report says Xbox has made the Xbox app available through Samsung Gaming Hub in select regions. If that is your setup, the Samsung Gaming Hub, LG Gaming Portal and Fire TV comparison lists what each hub carries. A TV built on any of those platforms uses the same router-counter method.
Step 10: Write the Budget Report
Now the part that turns measurements into decisions. budget.py reads every row in the ledger, groups them by device, service and quality, and works out the average megabytes per minute for each group. It then looks at your monthly cap, subtracts your household’s other usage and the cloud gaming already logged this month, and tells you how many full free sessions the rest of the month can hold.
import sys
from collections import defaultdict
from datetime import datetime
import ledger
def main():
plan = ledger.load_plan()
rows = ledger.read_all()
if not rows:
sys.exit("sessions.csv is empty. Log a calibration session first.")
cap_mb = plan["monthly_cap_gb"] * 1000
other_mb = plan.get("other_usage_gb_this_month", 0) * 1000
session_min = plan["session_cap_minutes"]
month = datetime.now().strftime("%Y-%m")
totals = defaultdict(lambda: [0.0, 0.0])
cloud_mb_month = 0.0
for r in rows:
minutes = float(r["minutes"] or 0)
if minutes <= 0:
continue
mb = float(r["mb_down"] or 0) + float(r["mb_up"] or 0)
key = (r["device"], r["service"], r["quality"])
totals[key][0] += mb
totals[key][1] += minutes
if r["start"][:7] == month:
cloud_mb_month += mb
used_mb = other_mb + cloud_mb_month
pct = used_mb / cap_mb * 100
left_mb = max(cap_mb - used_mb, 0)
print(f"Month {month}: {used_mb / 1000:.1f} GB of {cap_mb / 1000:.0f} GB used ({pct:.1f}%)")
print(f"Cloud gaming logged this month: {cloud_mb_month / 1000:.2f} GB\n")
print(f"{'device':<12}{'service':<18}{'quality':<10}{'MB/min':>8}{'GB/hr':>8}{'sessions left':>15}")
for (device, service, quality), (mb, minutes) in sorted(totals.items()):
rate = mb / minutes
per_session = rate * session_min
sessions = int(left_mb // per_session) if per_session else 0
print(f"{device:<12}{service:<18}{quality:<10}{rate:>8.1f}{rate * 60 / 1000:>8.2f}{sessions:>15}")
warn, crit = sorted(plan.get("alert_percent", [80, 95]))
level = 2 if pct >= crit else 1 if pct >= warn else 0
print("\nSTATUS:", ["OK", "WARN", "CRITICAL"][level])
sys.exit(level)
if __name__ == "__main__":
main()The math is deliberately plain. The rate for a group is total megabytes divided by total minutes, so a long session counts for more than a short one. Sessions left is the remaining allowance divided by the rate times your session cap. The exit code is 0 for OK, 1 for WARN and 2 for CRITICAL, so another script or a scheduler can react to the result without parsing text.
Notice what the script does not do. It never guesses a rate for a service you have not measured, and it never reads a number from the internet. Every figure in the report traces back to a row in your own ledger, which is exactly why you can trust it.
How the report calculates sessions left
Walk through the sample logic used later in Step 11. The script adds the household’s existing usage to the cloud gaming total in the ledger, subtracts that from the monthly cap, and converts what remains into megabytes. It then divides that by the data one 60-minute session uses for each group, the PC group and the Fire TV group, and rounds down to whole sessions.
The report adds upload to download when it computes a rate. Upload is usually small for a stream because you are sending controller input, not video, but it is real traffic and your provider counts it. That is why the PC row shows 62.0 MB per minute while the meter’s own summary printed 60.0 for download alone. The router rows carry download only, because most router pages show one combined figure or a download figure per device.
Steps 11 and 12: Run the Report and Add Cap Alerts
Step 11: Run the report. With the three sample sessions from the earlier steps logged, run the script.
python budget.pyMonth 2026-10: 413.9 GB of 1000 GB used (41.4%)
Cloud gaming logged this month: 1.90 GB
device service quality MB/min GB/hr sessions left
chromebook geforce-now-free balanced 58.0 3.48 168
firetv xbox-cloud default 70.0 4.20 139
pc geforce-now-free balanced 62.0 3.72 157
STATUS: OKThis output comes from invented sample data, so do not read it as a statement about any service’s real bitrate. What matters is the shape. You get one line per device and service, a clear hourly rate and a count of sessions your cap can still absorb. Check the first line against your provider’s portal. If the two totals disagree by more than a few gigabytes, you have a unit or interface problem rather than a gaming problem.
Open sessions.csv after the three sessions and you will see one row each. The PC row came from the meter and carries upload and peak rate. The Chromebook and Fire TV rows came from the manual logger, so those two columns stay empty and the method column says router.
start,device,service,quality,minutes,mb_down,mb_up,peak_mbps,method
2026-10-24T19:05:00,pc,geforce-now-free,balanced,10,600,20,14.2,psutil
2026-10-24T23:37:54,chromebook,geforce-now-free,balanced,10.0,580.0,,,router
2026-10-24T23:37:54,firetv,xbox-cloud,default,10.0,700.0,,,routerValidate the ledger against your provider’s portal once, early. Note the portal’s total, play a ten-minute session, wait for the portal to refresh and compare the change. Portals often lag by hours, so do this check on a quiet evening and read the figure the next morning. If the portal moved by roughly what your ledger says, your method is sound. If it moved by much more, something else on the network was busy. If it moved by much less, the portal may count in a different unit or exclude certain traffic.
Step 12: Add cap alerts. A report you forget to run protects nothing. Raise the household usage in plan.json and the same script reacts once the warning level has been crossed.
Month 2026-10: 821.9 GB of 1000 GB used (82.2%)
Cloud gaming logged this month: 1.90 GB
device service quality MB/min GB/hr sessions left
chromebook geforce-now-free balanced 58.0 3.48 51
firetv xbox-cloud default 70.0 4.20 42
pc geforce-now-free balanced 62.0 3.72 47
STATUS: WARNNow schedule it. On Linux or macOS, a weekly cron entry runs the report on Sunday evening and sends you a message only when the exit code is not zero. Swap the mail command for whatever notifier you use.
# crontab -e
0 20 * * 0 cd $HOME/cloudmeter && .venv/bin/python budget.py > report.txt || mail -s "Cloud gaming data cap warning" [email protected] < report.txtOn Windows, a scheduled task does the same job. This command registers a weekly task that writes the report to a text file you can open or forward.
schtasks /Create /SC WEEKLY /D SUN /ST 20:00 /TN "CloudMeterBudget" /TR "cmd /c cd /d C:\Users\you\cloudmeter && .venv\Scripts\python.exe budget.py > report.txt" Remember to refresh other_usage_gb_this_month before the scheduled run. A stale figure is the usual reason an alert fires late.
Step 13: Cut Data Use Without Killing the Picture
Step 13: Run controlled experiments. With a trustworthy baseline in the ledger, you can finally test what saves data. The rule is to change one thing per ten-minute session and give each variant its own quality label. If you change the resolution and the frame rate together, you will never know which one did the work.
| Change one thing | Hold constant | Example quality label |
|---|---|---|
| Lower the stream resolution in the service settings | Game, scene, device, Wi-Fi band | res-lower |
| Lower the frame rate cap | Game, scene, device, Wi-Fi band | fps-lower |
| Pick the service’s data-saving quality preset, if it has one | Game, scene, device | preset-saver |
| Toggle the DLSS 4.5 controls on GeForce NOW | Game, scene, device | dlss-on or dlss-off |
| Switch the device from Wi-Fi to Ethernet | Game, scene, quality setting | wired |
| Use the ad-supported free route against a paid pack on Xbox | Game, scene, device | ads or ad-free |
Keep the scene identical, because a different level changes the stream. Pick a spot you can reach in under a minute, such as the first area of a game, and play the same loop each time. Run each variant at least twice and look at whether the two runs agree before you trust the difference.
The report will tell you quickly whether a change is worth keeping. A setting that trims the rate by a few megabytes a minute might not matter on a generous plan but could add several sessions to a tight one. Your measured answer also helps when you pick between services. A head-to-head such as GeForce NOW against Xbox Cloud Gaming covers features and pricing, and your ledger adds the missing column, which is what each one costs your connection.
Last, write a short note in the quality label for anything that might skew a run, for example a background download or a family member streaming video. A single odd row stands out in a CSV when you can read why it happened.
Expect some surprises. A setting you assumed would help may change little, and a setting you ignored may change a lot. That is a feature of measuring. When a result looks wrong, repeat it before you act, because one noisy run is enough to mislead you. Once two runs agree, update the quality label you use for everyday play so the report forecasts the way you actually behave.
Common Pitfalls
- Metering the wrong interface. If the meter reads zero or a trickle during a busy session, you picked an idle adapter, such as a virtual or loopback interface. Re-run
--listand choose the one whose total climbs while you play. - Starting the clock during the queue. Waiting for a free session moves almost no data, so counting those minutes drags your rate down and makes your budget look better than it is. Start the meter when the game appears.
- Mixing units. Routers, operating systems and providers disagree about whether a gigabyte is 1,000 or 1,024 megabytes. Pick one convention, keep it, and check the report’s total against the provider portal.
- Calibrating once and trusting it forever. One ten-minute session in a quiet area is a data point, not a rate. Log at least two sessions per setup and a mix of busy and calm scenes.
- Ignoring the rest of the household. The cap is shared. If other people stream video all evening, your cloud gaming budget is smaller than the report suggests unless you keep
other_usage_gb_this_monthcurrent. - Treating all Fire TV models as identical. Amazon’s listings show different GeForce NOW availability by stick, reportedly with coming soon labels on some. Test the model you own, and do not copy another household’s results.
- Confusing cloud hours with gigabytes. An Xbox allowance of 5, 10 or 15 hours says nothing about data. The data ceiling is the allowance multiplied by your measured rate, which is the number this tool exists to find.
A related trap is mixing ad-supported and ad-free sessions in one label. Advertising video and game video are not the same stream, so log them separately and compare.
Troubleshooting
- Interface not found. The message
Interface 'Wi-Fi' not foundmeans the name does not match. Runpython meter.py --listand copy the name exactly, including capitals and spaces. - ModuleNotFoundError for psutil. The virtual environment is not active. Run the activation command from Step 2 and try again.
- PowerShell blocks Activate.ps1. Run
Set-ExecutionPolicy -Scope Process RemoteSignedin that window, then activate again. The change applies only to the current session. - The meter shows zero megabytes. You chose an idle adapter, or the game is running on a different machine than the one you are metering. Confirm that the total in
--listrises while the stream plays. - Totals far higher than expected. Something else is using the connection. Pause cloud backups, system updates and game downloads, then re-run the test.
- sessions.csv is empty or missing. The scripts write to the folder you run them from. Change into the project folder first, then run the command again.
- Router counter never changes. The traffic monitor feature is probably off, or the page updates slowly. Enable it, wait a minute and refresh before you start the test.
- Router values look rounded. The page shows gigabytes to one decimal place. Use
--unit gbwith a longer session, or switch to a view that reports megabytes. - Report says sessions left is 0. Your other usage already exceeds the cap, or
session_cap_minutesis much larger than your real session. Fix the plan file and run again. - Ctrl+C does not log the session on Windows. Some terminals handle the signal differently. Use the
--minutesflag so the script ends itself and writes the row. - The Fire TV does not offer GeForce NOW. Your model may still be marked coming soon in Amazon’s listing. Check the listing, update the stick’s software and fall back to Luna or Xbox for now.
Advanced Tips
- Skip Python entirely for a quick check. On Windows,
(Get-NetAdapterStatistics -Name "Wi-Fi").ReceivedBytesreturns the adapter’s received bytes. On Linux, read/sys/class/net/wlan0/statistics/rx_bytes, and on macOS, runnetstat -I en0 -b. Subtract a before reading from an after reading and you have the same number meter.py would give you. - Use vnStat for always-on history. On a Linux box or a small home server, vnStat keeps daily and monthly totals per interface, and
vnstat -l -i wlan0shows live traffic. It does not label sessions, but it is a good cross-check on your ledger. - Move the ledger into a spreadsheet. The CSV opens directly in any spreadsheet. A pivot table by service and quality gives you averages, and a chart of weekly gigabytes shows whether a habit is creeping up.
- Add a device label as new hardware arrives. NVIDIA said on September 24, 2026 that GeForce NOW support was coming to Googlebooks, Google’s new laptop category, with availability details still to follow. When those machines ship, log them under their own device name rather than lumping them in with Chromebooks.
- Plan a tethered-phone budget. Set
monthly_cap_gbto your mobile plan, setother_usage_gb_this_monthto what the phone has used and let the report tell you whether a hotspot session is sensible at all. - Tag sessions by game when you have a favorite. If one title dominates your play, put its name in the quality label. A month later you can see whether that single game accounts for most of your cloud gaming data.
- Share the ledger safely. If several people use the tracker, keep the folder in a synced drive and give each person a device label. Do not store account passwords or tokens in the plan file, because it only needs numbers.
- Prefer a wired connection for calibration. Ethernet removes Wi-Fi retries from your numbers, so your baseline reflects the stream itself. Then test Wi-Fi as a variant and compare. For more guides in this area, browse the cloud gaming and emulation coverage.
Frequently Asked Questions
Is free cloud gaming really free? The services can charge nothing for access, but your connection still carries a continuous video stream. If your internet plan has a monthly cap, free sessions spend that allowance. If you use a mobile hotspot, they spend that one instead.
How much data does free cloud gaming use per hour? It depends on the service, the quality setting, the resolution, the frame rate and the game. This guide deliberately avoids a single figure because a wrong one would mislead you. Run the tracker for ten minutes per setup and read the GB per hour column.
Can I run meter.py on a Chromebook? You can run it inside the Linux container, but it will only see that container’s traffic and miss the Chrome browser and the GeForce NOW app. Use the router counter with manual.py for Chromebooks.
Does Xbox Cloud Gaming have a free tier? Microsoft’s official pages do not show a permanent, unrestricted free tier like GeForce NOW’s. Xbox began testing free, ad-supported play and paid Cloud Playtime packs with Insiders on October 21, 2026, and the broader rollout is reportedly planned for November. Check the Xbox site for the current state before you rely on it.
Does a Fire TV Stick run GeForce NOW? It depends on the model. Amazon’s listings show GeForce NOW as available on some sticks and marked coming soon on others, and NVIDIA documents buying Performance or top-tier memberships through Amazon on supported sticks. Check the listing for your exact model.
Do ad-supported sessions use less data? Nobody can answer that without measuring, because the ads are extra video on top of the game stream. Log ad-supported and ad-free sessions under separate quality labels and let your own ledger decide.
Does a Cloud Playtime pack change how much data I use? No. A pack sets how many hours you can stream, not how many megabytes each hour costs. Multiply the hours by your measured MB per minute to find the gigabytes.
Can I track services that are not covered here? Yes. The labels are free text, so any streaming service, game or setting works. Measure it for ten minutes, log it with a new service label and the report adds a row for it.
Should I use Ethernet for cloud gaming? If your device has a port, yes. A wired connection removes Wi-Fi interference from your tests and from your play, so it is the best baseline for the numbers in this guide.
