DEV Community: Amrendra Singh

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

Amrendra Singh — Sat, 07 Nov 2026 21:06:25 +0000

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.

Item	What the docs showed (7 Nov 2026)
GPU option	T4 x2 (2 x 15 GB), P100 also mentioned
CPU and RAM	4 cores, about 29 GB
Weekly GPU quota	About 30 hours, sometimes higher; see Settings
Session cap	About 12 hours (TPU about 9)
Saved storage	About 20 GB in /kaggle/working
Idle timeout	Quoted as 20 minutes on one docs page and 60 on another

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:

Account > Settings > verify your phone number.
Create a notebook (New Notebook).
Right-hand panel: Accelerator > pick the T4 x2 option.
Same panel: Internet > On.
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.

Problem	Likely cause	Fix
Run cancels about a minute in	Weekly quota used up	Check Settings; wait for reset
Notebook still uses old data	Dataset version not updated	Input panel > Check for updates > Update
Session hangs on `apt-get`	System package install stalls	Use `pip`, or download a binary with `curl`
A step breaks after a library update	Version clash	Pin the version, for example `pip install "transformers<5"`
Out of memory	Model or image too big for 15 GB	Smaller batch or size; keep one job per GPU
Editor freezes mid-run	Long job in interactive mode	Use Save & Run All instead

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.

Render Blender Online Free: Headless on a Kaggle GPU

Amrendra Singh — Sat, 07 Nov 2026 19:19:16 +0000

You can render Blender online free by running it headless inside a Kaggle notebook with a GPU switched on. You download the official Linux build, point it at your .blend file, and save frames to the notebook's output folder. It suits learning and testing. Kaggle's terms limit it to personal, non-commercial use, so read the terms section before you try it for anything else.

Can you really render Blender on a free cloud GPU?

Yes, for tests and personal projects. A Kaggle notebook is a Linux machine with a GPU attached. Blender runs without its window ("headless"), reads your scene, and writes images. There is no remote desktop and no viewport. You send a command and collect the files.

When we checked the docs, the GPU option listed was two Tesla T4 cards with 15 GB each, 4 CPU cores and 29 GB of RAM. Specs change, so check the current Kaggle docs before you plan around them.

Colab is another free route for blender cloud rendering. We have not tested Blender there, so this guide covers Kaggle only.

What do you need before you start?

You need a Kaggle account, a verified phone number, and a .blend file that renders cleanly on your own machine first. Phone verification is what unlocks both the GPU and internet access in notebooks. Without internet, you cannot download Blender.

Prepare your scene like this:

Pack your textures. Use File > External Data > Pack Resources, so the .blend carries its images.
Set output and sampling in the file. Resolution, samples and denoising should be what you want.
Use Cycles. We only tested Cycles in headless mode.
Keep it small. Upload the .blend as a private dataset, so the notebook can read it from the Input panel.

How do you turn on the GPU and internet?

Open a new notebook, then open the settings side panel. Set the accelerator to a GPU option and switch Internet on. Both settings need a verified phone. The weekly GPU quota is shown on your account Settings page, so check it there before a long job.

Run this in the first cell to confirm the card is visible (in a notebook cell, start shell lines with ! or put %%bash on the first line):

nvidia-smi

If you see a Tesla T4 listed, you are ready. If the cell fails, the GPU toggle is off or the session did not restart after you changed it.

How do you install Blender in a notebook?

Download the official Linux build from download.blender.org, unpack it into a scratch folder, and call it by its full path. Do not use apt-get as your first move. In our test it hung a session, and the download needed no extra packages.

cd /tmp
curl -L -o blender.tar.xz "https://download.blender.org/release/Blender4.2/blender-4.2.X-linux-x64.tar.xz"
tar -xf blender.tar.xz
/tmp/blender-4.2.X-linux-x64/blender -b --version

Replace X with the current point release listed on that page (we used 4.2.23). In our test we used Blender 4.2 LTS, about 334 MB, and it ran with no extra libraries. If --version complains about a missing library, install only the ones it names.

What is the headless render command?

Run Blender in background mode with -b, load your scene, run a short Python setup script, then render. Here is the shape of it for one frame:

/tmp/blender-4.2.X-linux-x64/blender -b --factory-startup \
  /kaggle/input/my-scene/scene.blend \
  -E CYCLES \
  -P /kaggle/working/gpu_setup.py \
  -o /kaggle/working/frame_#### \
  -f 1

Order matters. Blender reads arguments left to right, so the Python script runs before the render flag fires. For an animation, swap -f 1 for -a to render the full frame range stored in the file.

How do you choose OptiX or CUDA?

Choose OptiX on RTX and T4-class cards, and fall back to CUDA if OptiX is not offered. Both are GPU back ends for Cycles. OptiX is usually faster on cards that support it. In our test Cycles used OptiX on both T4s, with CUDA as the fallback.

Here is a short generic script that tells Cycles which device type to use and switches every GPU on:

import bpy

prefs = bpy.context.preferences.addons["cycles"].preferences
prefs.compute_device_type = "OPTIX"   # change to "CUDA" if OptiX fails
prefs.get_devices()

for device in prefs.devices:
    device.use = device.type != "CPU"
    print(device.name, device.type, device.use)

bpy.context.scene.cycles.device = "GPU"

Save it as gpu_setup.py. The print lines go to the log, so you can confirm which cards rendered. If the list shows only a CPU, Cycles did not find a GPU, so go back and check the notebook settings.

Where should you save the output?

Save finished frames to /kaggle/working, and put big temporary downloads in scratch. Only the working folder is kept as notebook output, and it is about 20 GB. Scratch space is not saved when the run ends, but it is roomy.

Location	Saved after the run?	Good for
/kaggle/working	Yes, appears as output	Final frames, logs, small files
/tmp or /kaggle/tmp	No	The Blender download, caches, test renders
/kaggle/input	Read-only	Your .blend and textures

In our test, scratch showed over a terabyte free. Treat that as a reading from one run, not a promise. Your animation also has to fit inside the 20 GB working limit, so render to compressed PNG or JPEG, or write video from a later step.

Commit run or interactive editor?

Use a commit run for anything longer than a quick test. In our test the interactive editor froze under long jobs, while "Save Version", then "Save & Run All", ran reliably and kept logs in the Logs tab.

A commit run executes your notebook top to bottom without a browser tab holding it open. Output files are collected when it finishes. Sometimes a finished run needs a minute before the files become downloadable, so wait before you assume it failed.

How do you download your renders?

Open the finished version, go to the Output tab, open the menu and choose Download output. You get one zip with everything from /kaggle/working. If you rendered an image sequence, unzip it and assemble the frames in your editor or compositor.

Keep a log line at the end of the notebook that lists the output folder. It makes it easy to see what was saved.

What are the limits?

Three limits matter: the weekly GPU quota, the session length, and the output size. Check each on the official docs and your Settings page, because they change.

Weekly quota. When we read the docs, it was about 30 GPU hours a week, "or sometimes higher". Your Settings page shows your actual figure.
Session cap. About 12 hours for a GPU session. Idle timeouts are quoted differently on different docs pages, so check the current one.
Output. About 20 GB in the working folder.
One run at a time. In practice a second job on the same account was cancelled in our test. If runs cancel about a minute into setup, look at your quota first.
Memory. Running out of GPU memory is the crash to expect. A heavy scene can fail on a 15 GB card.

What did our test show?

In our test (7 November 2026, two Tesla T4 GPUs), setup took about 28 seconds. One 1080p still at 128 samples took about 30 seconds, including the first-time kernel load. The whole run, from first cell to saved image, took about two to three minutes.

That is one scene and one run, so treat it as a rough guide. Your numbers depend on your geometry, lights and sample count.

What we did not test is the cost per frame of a full animation. We cannot tell you how long 240 frames would take, or whether a long job would hit the session cap. Render a few frames first, time them, and multiply, before you commit your weekly quota.

What do Kaggle's terms say?

Kaggle's terms limit use of the service to your own internal, personal, non-commercial use. Its acceptable use policy also rules out activity unrelated to machine learning and data science. That is why we frame this setup as learning and testing.

Please read the current terms yourself before you run anything on it. Do not use a free Kaggle notebook to render work for a paying client. For commercial rendering, use a paid render farm or your own GPU. Both give you terms that allow that kind of work and capacity you can plan around.

FAQ

Q: Can I render Blender online free without a credit card?
On Kaggle you need a verified phone number, not a card. Check the current signup steps, since they can change.

Q: Does Blender work on Colab too?
Colab is another free option. We have not tested Blender there, so we cannot give you steps or results.

Q: Does headless Blender need a display?
No. Use -b and render with Cycles. There is no window to open.

Q: Which is better for Blender headless render, OptiX or CUDA?
OptiX is usually faster where available. Keep CUDA as the fallback, and set it in the same script.

Q: Can I use this for client animation?
No. Free notebooks are for personal, non-commercial use under Kaggle's terms. Use a paid farm or your own GPU for client work.

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