Kaggle GPU Free Limit: What You Get and How to Use It

Kaggle gives every verified account free GPU time in notebooks. The Kaggle GPU free limit is a weekly quota (roughly 30 hours, sometimes higher), plus a cap on how long one session can run. Your exact number is shown on your Settings page, so read it there. This guide covers turning the GPU on, staying inside the limits, and fixing the errors beginners hit first.

Figures below are what the Kaggle docs showed when we read them on 7 Nov 2026. Limits change, so check the current docs at https://www.kaggle.com/docs/notebooks and https://www.kaggle.com/docs/efficient-gpu-usage before you plan around any number.

What do you get with the Kaggle free GPU?

The docs list an accelerator called "T4 x2": two Tesla T4 GPUs with about 15 GB of memory each, plus 4 CPU cores and about 29 GB of RAM. The docs still mention a P100 option as well. Weekly GPU time is about 30 hours, and a single session is capped at about 12 hours.

The idle timeout is the one to check yourself. Two docs pages disagree, so treat the shorter figure as the safe one.

How do you turn on the GPU in a Kaggle notebook?

Verify your phone number first, since both internet access and GPUs need it. Then open a notebook, open the settings panel on the right, choose a GPU under Accelerator, and switch Internet on if you need to download files. The session restarts when you change the accelerator.

Steps in order:

1. Account > Settings > verify your phone number.
2. Create a notebook (New Notebook).
3. Right-hand panel: Accelerator > pick the T4 x2 option.
4. Same panel: Internet > On.
5. Run a quick check in the first cell:

import torch print(torch.cuda.is_available(), torch.cuda.device_count()) for i in range(torch.cuda.device_count()): print(i, torch.cuda.get_device_name(i)) 

If it prints True 2 and two T4 names, you are set. A False usually means the accelerator is still set to None.

How do sessions, idle timeout and the weekly quota work?

A session is one running machine. It ends when you stop it, when it sits idle too long, or when it hits the session cap. GPU hours count against your weekly quota while the session is on, so close sessions you are not using.

Three habits save quota:

• Write and debug code on the CPU setting, then switch to GPU for the real run.
• Stop the session when you finish. Do not leave a tab open overnight.
• In our test only one run went at a time: a second push was cancelled.

If runs cancel about a minute into setup, check your weekly quota first. That is the most likely cause.

If you pay for Colab Pro or Pro+, Kaggle has offered extra weekly GPU hours when you link the two accounts. Check the current offer on Kaggle's settings or docs page before you count on it.

Where are files saved, and what disappears?

Anything written under /kaggle/working is saved as the notebook's output, up to about 20 GB. Anything outside it, such as /kaggle/tmp, is scratch space and is not saved. In our test, scratch showed about 1.1 TB free on a T4 session.

Use that to your advantage. Download big files to scratch, process them there, and copy only the results into /kaggle/working.

import os os.makedirs("/kaggle/tmp/big", exist_ok=True) # not saved, lots of room os.makedirs("/kaggle/working/results", exist_ok=True) # saved as output 

Commit run or the interactive editor?

Use the interactive editor to write and test short pieces. Use a commit run (Save Version > Save & Run All) for anything long. In our test on a T4, the interactive editor froze under long runs, while commit runs finished reliably and wrote logs to the Logs tab.

With a commit run, outputs are exported when the run ends. To get them, open the Output tab, use the menu, and choose Download output, which gives you a zip. A run marked complete can need a minute before the download appears.

How do you cache large files as a private dataset?

Most setup time is downloading large files such as model weights, not installing packages. Download them once in a CPU notebook, then publish the notebook's output as a private dataset (Output tab > New dataset). Later notebooks attach that dataset and skip the download.

Keep each build under the 20 GB working limit. Private datasets have their own storage quota (the docs listed about 214 GB when we read them; check yours).

One thing that did not work in our test: the dataset "Remote URL" option failed when the source used redirects. Downloading in a notebook and saving the output was more dependable.

How do you use Kaggle datasets, and update them?

Add data from the Input panel: search public datasets, or attach your own. Files appear under /kaggle/input/<dataset-name>/. Input is read-only, so copy anything you need to change.

import os for root, dirs, files in os.walk("/kaggle/input"): print(root, len(files), "files") 

When you publish a new version of a dataset, your notebook keeps using the old one. Open the Input panel, open the dataset's menu, choose Check for updates, then Update. Without this step you will wonder why your fix did nothing.

Can you use both GPUs at once?

Yes, but most single jobs only use one. The simple approach is two separate processes, each pinned to one GPU with CUDA_VISIBLE_DEVICES. Stagger the starts a little so they do not compete for the CPU and disk at the same moment.

import subprocess, os, time def launch(gpu, script, *args): env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu)) return subprocess.Popen(["python", script, *args], env=env) p0 = launch(0, "job.py", "--part", "a") time.sleep(20) p1 = launch(1, "job.py", "--part", "b") p0.wait(); p1.wait() 

In our test (28 Oct to 7 Nov 2026, two T4s), running two independent jobs this way took roughly half the wall time of running them one after another. That is one test, not a benchmark.

What are the common errors and fixes?

Most problems are one of a handful of things. Here they are with the fix that worked for us.

For the version clash, a pin fixed an audio step that broke after a major library release in our test. Write down your working versions in the notebook so you can repeat them.

What do Kaggle's terms allow?

Kaggle's free compute is for learning and testing. The Terms (June 2025) limit use to your "own internal, personal, non-commercial use". The Acceptable Use Policy bans activity "unrelated to ML data science". So use it for study, practice and personal experiments.

What to stay clear of:

• Commercial or paid work for other people.
• Anything that has nothing to do with machine learning or data science.

Read the current Terms and policy yourself before you start. They are the rule, not this article.

FAQ

Q: What is the Kaggle GPU free limit?
A weekly quota of roughly 30 hours (sometimes higher) plus a session cap of about 12 hours. Your own number shows on the Settings page.

Q: How do I use Kaggle GPU for the first time?
Verify your phone, create a notebook, set Accelerator to a GPU, turn Internet on if you need it, and confirm with torch.cuda.is_available().

Q: Why did my Kaggle notebook cancel after a minute?
Usually the weekly GPU quota is spent. Check Settings.

Q: Do I lose files when the session ends?
Files in /kaggle/working are saved as output. Scratch space outside it is not.

Q: How do I use Kaggle datasets in a notebook?
Attach them from the Input panel and read them from /kaggle/input/. Update the dataset version in the panel when you publish a new one.

Originally published at mainstreetprofile.com. We make product videos and 3D animated shorts for brands and agencies: see the samples.