Kaggle

kaggle.com · 9 records in Compute, Storage · JSON

Records 9

★ qualifiesKaggle Notebooks, free Notebooks (CPU, GPU, TPU)
Computefree tieridentity any-phoneno cardlimit volume-quotaevidence documentedstale on 2026-11-24
★ qualifiesKaggle Datasets (public)
Storagefree tieridentity institution?card?evidence documentedstale on 2026-11-21
caveatKaggle Notebooks (compute/kaggle)
Computefree tieridentity email?card?limit request-rateevidence documentedstale on 2026-11-30duplicate
caveatKaggle Benchmarks
Computefree tieridentity emailno cardlimit write-gatedevidence documentedstale on 2026-12-05
caveatKaggle dataset quota-request program (the >200 GB escape hatch)
Storagefree tieridentity email?card?limit write-gatedevidence reportedstale on 2026-11-05
caveatKaggle Models (distinct from Kaggle Datasets)
Storagefree tieridentity emailno cardlimit per-object-capevidence reportedstale on 2026-11-05
caveatKaggle Notebook outputs (/kaggle/working) — the free side-channel
Storagefree tieridentity email?card?evidence reportedstale on 2026-11-05
caveatKaggle Notebooks + Datasets
Storagefree tieridentity card?card?evidence reportedstale on 2026-11-05
fails: quotakaggle notebooks as a server
Storageidentity email?card?evidence reportedstale on 2026-11-05

Kaggle Notebooks, free Notebooks (CPU, GPU, TPU)

Compute

www.kaggle.com/docs/notebooksNotebook runtimecompute/kaggle-notebooksJSON compare report an error

Free allowance: 4 CPU cores and 30 GB RAM, or 1 Tesla P100 with 29 GB RAM, per session; 12 hours of execution for CPU and GPU sessions and 9 hours for TPU; 20 GB of auto-saved disk in /kaggle/working; a weekly GPU quota of 30 hours or more
Verdict: ★ qualifiesusable as stated; the read path was probed
Cost: free tier
Identity: any-phoneno card, phone required
Binding limit: volume-quota30 GPU hours a week, resetting weekly, sometimes higher; 12 hours of execution per CPU or GPU session; 9 hours for TPU
Evidence: documented11 sources; a first-party page was read and the sentence quoted
Freshness: stale on 2026-11-24checked 2026-10-24 (live); stale on 2026-11-24

Free tier	4 CPU cores and 30 GB RAM, or 1 Tesla P100 with 29 GB RAM, per session; 12 hours of execution for CPU and GPU sessions and 9 hours for TPU; 20 GB of auto-saved disk in /kaggle/working; a weekly GPU quota of 30 hours or more unit hours; metered on wall-clock; The 30-hour figure is the GPU quota; the 12-hour figure is the per-session cap. They are different clocks.
Price	none stated
Limits	volume-quota (binding) 30 GPU hours a week, resetting weekly, sometimes higher source volume-quota (binding) 12 hours of execution per CPU or GPU session; 9 hours for TPU source write-gated phone verification gates the GPU accelerator and the Internet toggle source the free accelerator is a single P100; TPU v3-8 is also offered
Binding	volume-quota the 30 GPU-hour weekly quota is what runs out; the 12-hour session cap is large enough that a job normally meets the quota first
Identity	any-phone an email account, plus phone verification before the GPU accelerator or the Internet toggle can be switched on; no card. The requirement is not on the two documentation pages read, so it is carried at reported confidence from Kaggle's own product-feedback threads, where the fix for a disabled Internet toggle is 'Verify your phone.'
Egress	not published on the pages read: the Internet toggle governs outbound access and states no allowance and no price
Per-object cap	not applicable: the unit is a session, not an object
Retention	20 GB of /kaggle/working is auto-saved and reusable in a later notebook; anything outside /kaggle/working is lost when the session ends
Interface	rest, cli a notebook in the browser; a Jupyter server that Colab can also attach to
Tooling	Jupyter, the Kaggle API for datasets and notebook versions
Composes with	30 GPU hours a week is the largest recurring GPU allowance in this class
Reliability	interactive sessions are reaped after 20 minutes idle, and free GPU capacity queues at busy times
Notes	The two Kaggle pages disagree on the interactive idle timeout: the GPU page says 'Interactive sessions remain active until they reach the 60 minute idle timeout limit' while the notebooks page says 20 minutes. Both were read. The notebooks page is the more specific statement, so this record carries 20 minutes and the disagreement is flagged rather than averaged.
Evidence note	documented shape, session length, disk and the GPU quota are quoted from two first-party pages read. The phone gate is reported, not documented.
Parsed numbers	price USD 0 10 hours a day / month price USD 0 / month has-free-tier 1 volume-quota 30 GPU hours / week volume-quota 12 hours

Evidence 11

date	source	what it proved
2026-10-22	www.kaggle.com/docs/efficient-gpu-usage	the GPU quota is 30 hours a week or sometimes higher depending on demand and resources; it resets weekly
2026-10-22	www.kaggle.com/docs/efficient-gpu-usage	interactive sessions remain active until the 60-minute idle timeout
2026-10-22	www.kaggle.com/docs/notebooks	a single NVIDIA Tesla P100 can be added free; availability is limited and queued
2026-10-24	www.kaggle.com/docs/notebooks	quoted: '12 hours execution time for CPU and GPU notebook sessions and 9 hours for TPU notebook sessions'
2026-10-24	www.kaggle.com/docs/notebooks	the Technical Specifications bullet list states, in separate bullets: '4 CPU cores', '30 Gigabytes of RAM', '1 Nvidia Tesla P100 GPU', '29 Gigabytes of RAM'
2026-10-24	www.kaggle.com/docs/notebooks	quoted: '20 Gigabytes of auto-saved disk space (/kaggle/working)'
2026-10-24	www.kaggle.com/docs/notebooks	quoted: 'While editing a Notebook, you are provided with 20 minutes of idle time for your interactive session.'
2026-10-24	www.kaggle.com/docs/notebooks	quoted: 'In order to save successfully, the entire Notebook must execute within 12 hours (9 hours for TPU notebooks).' — this is the headless path, and it needs no open tab
2026-10-24	www.kaggle.com/docs/efficient-gpu-usage	quoted: 'You can use up to a quota limit per week of GPU. The quota resets weekly and is 30 hours or sometimes higher depending on demand and resources'
2026-10-24	www.kaggle.com/docs/efficient-gpu-usage	quoted: 'Free GPU availability is limited: in busy times, you might be placed in a queue.'
2026-10-24	www.kaggle.com/product-feedback/255038	reported, not first-party documentation — a Kaggle product-feedback reply, captured in notes/raw/kaggle-phone-thread.md: 'Verify your phone. Click on your profile icon (top-right), go to settings and you'll find the option.'

More fields 15

shape	`{"vcpu": 4,"ram_gib": 30,"disk_gib": 20,"gpu_class": "Tesla P100","gpu_count": 1,"note": "CPU shape is 4 cores / 30 GB; the GPU shape drops to 29 GB. A T4 x2 shape is also listed."}`
billing model	free
granularity	`{"min_billed_s": null,"rounding_s": null}`
session cap	`{"wall_clock_min": 720,"idle_reap_s": 1200,"restart_required": false,"note": "12 h per session; 20 min interactive idle timeout; the headless run is the way to exceed the idle window"}`
keep rate	`{"value": 0.0,"basis": "a stopped session costs nothing","source": "https://www.kaggle.com/docs/efficient-gpu-usage"}`
persistent storage	`{"included_gib": null,"price_gib_month": null,"durability": "notebook versions persist; the runtime does not","survives_stop": false,"survives_destroy": false,"max_retention": "the session"}`
network out	`{"allow_outbound": true,"allow_inbound_listen": false,"ports": "outbound only, behind the Internet toggle","static_ip": false,"ipv6": false,"per_session_bytes": null}`
free tier kind	free-forever-with-quota
m10h usd	0.0
m24h usd	0.0
price arithmetic	USD 0.00 for the free allowance; no card and no cash price
term	none
unattended	yes
unattended mechanism	Save & Run All (the commit button) or `kaggle kernels push`: the notebook executes top to bottom in a separate session that does not need the browser tab
units	RAM and disk are quoted in the vendor's own decimal GB, not GiB. The ram_gib and disk_gib keys carry the vendor's number unconverted, so where a vendor writes 30 GB the key holds 30 and the true value is about 27.9 GiB. No conversion was performed.

Unknown values 1

egress metered: egress metering was not published

Kaggle Datasets (public)

Storage

www.kaggle.com/datasetsML hubstorage/kaggle-datasetsJSON compare report an error

Free allowance: 200 GB per dataset (hard, public or private), 50 top-level files per dataset, 200 GB max total PRIVATE datasets.
Verdict: ★ qualifiesusable as stated; the read path was probed
Cost: free tier
Identity: institution?placeholder, not evidence; card unknown, phone unknown
Binding limit: noneno named constraint binds
Evidence: documented6 sources; a first-party page was read and the sentence quoted
Freshness: stale on 2026-11-21checked 2026-10-21 (inherited); stale on 2026-11-21

Free tier	200 GB per dataset (hard, public or private), 50 top-level files per dataset, 200 GB max total PRIVATE datasets. There is NO documented aggregate cap on public datasets — the docs' 'Technical Specifications' section states only '200GB per dataset limit', '200GB max private datasets', 'A max of 50 top-level files'. Public total is therefore effectively unlimited per account, and the 200 GB/dataset ceiling is raised on request (see quota-program candidate). unit GB; metered on unstated
Price	none stated
Identity	institution (inferred, not read) not published
Egress	Free and CDN-backed: the download endpoint 302s to a signed storage.googleapis.com URL (Google Cloud Storage), which is Fastly/Google-fronted. No egress quota documented, no per-GB charge, no auth needed for public datasets.
Per-object cap	not stated
Retention	not stated
Interface	rest, rclone, cli rest
Tooling	kagglehub (pip install kagglehub, official, github.com/Kaggle/kagglehub) — resolves public datasets with NO credentials; kaggle-api CLI (`kaggle datasets download -d owner/slug`); plain HTTPS + curl/wget against /api/v1/datasets/download/<owner>/<slug>; rclone can front the signed GCS URL with an HTTP remote.
Composes with	200 GB x unlimited public datasets x unlimited free accounts. Live proof of the unlimited-public side: one account holds 23 public datasets totalling 1,197.7 GB with a largest single dataset of 163.0 GB (API-verified) — i.e. 6x over the 200 GB 'private quota' figure, so the private quota demonstrably does not apply to public datasets. Multiply again by Kaggle Organizations (a dataset can be owned by an org the account belongs to) and by the free quota-request program for >200 GB single datasets.
Reliability	Stable, corporate-owned (Google), no history of quota clawback; the failure modes are ingestion flakiness on very large uploads and un-deletable old versions, not data loss.
Evidence note	documented The page states the number in the record; the claim is documented, not measured.
Parsed numbers	has-free-tier 1

Evidence 6

date	source	what it proved
2026-10-22	www.kaggle.com/docs/datasets	the dataset size guidance. Re-read https://www.kaggle.com/docs/datasets: HTTP 200, 29944 bytes, sha256 1d2b0cd026b1e3a6. Quoted: --- title: "Datasets Documentation" words: 3998 upstream_status: 200 content_kind: page extraction: none source: provider contextdev title_source: provider final_url: "https://www.kaggle.com/docs/datasets" fetched_at: "2026-10-22T02:59:53.786Z" --- Kaggle uses cookies from Google to deliver and enhance the quality of its servi
2026-10-21	www.kaggle.com/docs/datasets#technical-specifications	'200GB per dataset limit', '200GB max private datasets (if you exceed this, either make your datasets public or delete unused datasets)', 'A max of 50 top-level files'
2026-10-21	www.kaggle.com/discussions/product-announcements/512322	Kaggle staff, 2 years ago: 'Users now have a limit of 200GB for private models and 200GB for private datasets. Kaggle has also doubled the maximum upload size of public models and datasets from 100GB to 200GB.'
2026-10-21	www.kaggle.com/api/v1/datasets/download/rounakbanik/pokemon	probe: curl -I -> 302 Location: https://storage.googleapis.com:443/kaggle-data-sets/2756/4568/bundle/archive.zip?X-Goog-... (signed, no auth required)
2026-10-21	www.kaggle.com/api/v1/datasets/download/wanghaohan/imagenets	probe: curl -r 0-62914559 -> 206, 62,914,560 bytes in 17.7 s = ~3.5 MB/s; on a 170 GB dataset (a public dataset of that account) same range -> 206, 104,857,600 bytes in 16.5 s = ~6.3 MB/s, anonymous
2026-10-21	source not published	probe: GET /api/v1/datasets/list?user=[account]&pageSize=100 -> 23 public datasets, 1,197.7 GB aggregate, max 163.0 GB single dataset

More fields 1

verified	`[{"url": "https://www.kaggle.com/docs/datasets","date": "2026-10-22","via": null,"http_status": 200,"bytes": 29944,"sha256": "1d2b0cd026b1e3a6cf001635d0efc4f18bbd4fdd9d6797e2655e713ef215491d","pattern_found": true,"what_changed": "no change: the page still states the claim","capture": null}]`

Unknown values 4

per object cap notes: the field may be stated in a source that was not read
per object cap stated: the field may be stated in a source that was not read
retention notes: the field may be stated in a source that was not read
retention stated: the field may be stated in a source that was not read

Kaggle Notebooks (compute/kaggle)

Compute

www.kaggle.com/docs/notebooksDev environmentcompute/kaggleJSON compare report an error

Free allowance: 30 hours of GPU a week: "You can use up to a quota limit per week of GPU.
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: email?placeholder, not evidence; card unknown, phone unknown
Binding limit: request-ratea free GPU or TPU is a session accelerator behind a queue; the wait is the constraint
Evidence: documented6 sources; a first-party page was read and the sentence quoted
Freshness: stale on 2026-11-30checked 2026-10-30 (live); stale on 2026-11-30

Free tier	30 hours of GPU a week: "You can use up to a quota limit per week of GPU. The quota resets weekly and is 30 hours or sometimes higher depending on demand and resources" unit hours; metered on wall-clock; The 30-hour figure is the weekly GPU quota; each session is capped at 12 hours for CPU and GPU and 9 hours for TPU. This slug exists only so a lookup for `kaggle` lands on the record; the provider's record is `kaggle-notebooks`.
Price	none stated
Limits	request-rate (binding) a free GPU or TPU is a session accelerator behind a queue; the wait is the constraint source retention-clamped changing the accelerator restarts the session, which loses in-memory state source not stated
Identity	email (placeholder) not published
Egress	not stated
Per-object cap	not stated
Retention	not stated
Interface	unknown
Reliability	no reliability event recorded
Notes	Duplicate slug. The provider's record is `kaggle-notebooks`, read on 2026-10-22. This record exists so a lookup for `kaggle` lands on the fact rather than a 404, and its verdict matches the real record so that no count taken over the directory reports Kaggle as dead.
Evidence note	documented the Notebooks documentation was read on 2026-10-22 and confirms the free GPU and free TPU switch and the queue. The record is a merge pointer to `kaggle-notebooks`, and the page is the same one that record cites
Parsed numbers	has-free-tier 1

Evidence 6

date	source	what it proved
2026-10-02	www.kaggle.com/docs/notebooks	not published
2026-10-22	www.kaggle.com/docs/notebooks	'##### Adding a free GPU' and '##### Adding a free TPU' with 'Your session will restart which may take a few moments to several minutes if you don't need to wait in a queue', quoted
2026-10-22	www.kaggle.com/docs/efficient-gpu-usage	quoted: the GPU quota resets weekly and is 30 hours, sometimes higher depending on demand; single P100 per session; interactive sessions stop at a 60 minute idle timeout
2026-10-22	www.kaggle.com/docs/efficient-gpu-usage	quoted: "You can use up to a quota limit per week of GPU"
2026-10-30	www.kaggle.com/docs/efficient-gpu-usage	the free GPU quota is 30 hours a week, sometimes higher, and resets weekly
2026-10-30	www.kaggle.com/docs/notebooks	each session runs at most 12 hours on CPU or GPU and 9 hours on TPU; the page states no weekly quota

More fields 9

keep rate basis	no field in the source
billing model	unclassified
shape	`{"vcpu": null,"ram": null,"disk": null,"gpu_class": "T4 or P100 class","gpu_count": 1,"note": "a single free GPU or a TPU v3-8 per session"}`
session cap	`{"wall_clock_min": null,"idle_reap_s": null,"restart_required": true,"note": "switching the accelerator restarts the session; the queue wait is unbounded"}`
free tier kind	allowance
duplicate of	kaggle-notebooks
count note	this record duplicates kaggle-notebooks; a count over the directory includes it twice
ps	`{"gib": null,"price": "notebook output is saved as a version, not a disk","durability": "notebook version","on_stop": true,"on_destroy": false,"retention": "the kernel's lifetime; output persists as a version"}`
net	`{"out": false,"in": false,"ports": "none","static_ip": false,"ipv6": false,"allowance": "internet access is available inside a notebook, but no inbound service"}`

Unknown values 10

chaining: a source was read and is silent on this field
egress metered: egress metering was not published
egress terms: a source was read and is silent on this field
interface: the access interface was not established
limits note: a source was read and is silent on this field
per object cap stated: a source was read and is silent on this field
reliability note: nothing of this kind was observed
retention notes: the field may be stated in a source that was not read
retention stated: a source was read and is silent on this field
tooling: a source was read and is silent on this field

Corrections

2026-10-22 Decided on 2026-10-22: compute/gitpod, compute/kaggle, storage/pulsedmedia-m10g-storage-box and 1 more record

Kaggle Benchmarks

Compute

www.kaggle.com/page/neurips-2026Cloud VMcompute/kaggle-benchmarksJSON compare report an error

Free allowance: Kaggle supplies compute and model access to whoever hosts a benchmark with it, quoted: 'High compute quota & model access: We provide a very high complimentary compute quota and access to leading models for your evaluations, including OpenAI, Google, Anthropic, Grok, Qwen, and DeepSeek.' The...
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: emailno card, no phone
Binding limit: write-gatedthe compute is attached to a published benchmark rather than to a person: the quota pays for evaluations that run on Kaggle, so it cannot be spent on a training run, and the larger NeurIPS allocation needs an accepted conference submission.
Evidence: documented5 sources; a first-party page was read and the sentence quoted
Freshness: stale on 2026-12-05checked 2026-11-04 (live); stale on 2026-12-05

Free tier	Kaggle supplies compute and model access to whoever hosts a benchmark with it, quoted: 'High compute quota & model access: We provide a very high complimentary compute quota and access to leading models for your evaluations, including OpenAI, Google, Anthropic, Grok, Qwen, and DeepSeek.' The open door for conference organisers, quoted: 'As a NeurIPS researcher, we provide additional complimentary compute and support by filling out. Just mention "NeurIPS 2026" in the form for expedited approvals.' The platform is self-serve, quoted: 'Getting started is quick and entirely self-serve. You can get started right away at www.kaggle.com/benchmarks'. unit none; metered on wall-clock; allowance
Price	none stated
Limits	write-gated (binding) the compute is attached to a published benchmark rather than to a person: the quota pays for evaluations that run on Kaggle, so it cannot be spent on a training run, and the larger NeurIPS allocation needs an accepted conference submission. source
Identity	email not published
Egress	not published: no egress allowance or overage price on https://www.kaggle.com/page/neurips-2026 or https://www.kaggle.com/docs/api, read 2026-11-04
Interface	rest, cli Python SDK kaggle-benchmarks, Kaggle Notebooks and a web UI at kaggle.com/benchmarks, plus the Kaggle public API and kaggle CLI; no SSH is published
Tooling	the provider documents the kaggle CLI, per the Kaggle API page: "kaggle CLI"
Composes with	This is the one route where a solo person can obtain model access to six frontier providers on one quota: the benchmark runs against OpenAI, Google, Anthropic, Grok, Qwen and DeepSeek models from a single Kaggle account, which is otherwise six separate signups with six separate cards. It composes with the free notebook quota in compute/kaggle-notebooks, because the SDK runs inside Kaggle Notebooks.
Reliability	no reliability event recorded
Notes	The amount is unverified by design: 'a very high complimentary compute quota' carries no number on any page read, so the record claims the mechanism and not the size. Three explanations for why the quota exists were considered: it subsidises benchmark supply for Kaggle's leaderboards, it is developer marketing for the model providers, and it replaces engineering work the labs would otherwise do. The page states the first two in its own words ('Managed infrastructure', 'Grow exposure to the Kaggle community'). The gate that matters is that the compute is scoped to evaluations, so a reader should not plan a fine-tune on it.
Parsed numbers	has-free-tier 1

Evidence 5

date	source	what it proved
2026-10-22	www.kaggle.com/page/neurips-2026	'High compute quota & model access: We provide a very high complimentary compute quota and access to leading models for your evaluations'; 'As a NeurIPS researcher, we provide additional complimentary compute and support by filling out. Just mention "NeurIPS 2026" in the form for expedited approvals'; 'Getting started is quick and entirely self-serve'; page 200 through a rendering provider, origin rate-limited with 'Too many requests to GetCurrentUser'
2026-10-22	neurips.cc/Conferences/2026/CallForCompetitions	'NeurIPS 2026 will be hosting a Competition Track, with a dedicated workshop for each accepted competition', read through the search index for neurips.cc
2026-11-04	www.kaggle.com/page/neurips-2026	a Python SDK and Kaggle Notebooks are the access routes; the page names no traffic-out term
2026-11-04	www.kaggle.com/docs/api	Kaggle publishes a CLI and a public API
2026-11-04	www.kaggle.com/docs/api	the Kaggle API page names the kaggle CLI

More fields 1

facets	`{"class": "benchmark-programme","free_tier_kind": "allowance","shape": {"vcpu": null,"ram_gib": null,"gpu_class": null,"gpu_count": null}}`

Unknown values 4

egress metered: egress metering was not published
per object cap stated: the field does not apply to this kind of offer
reliability note: nothing of this kind was observed
retention stated: the field does not apply to this kind of offer

Kaggle dataset quota-request program (the >200 GB escape hatch)

Storage

www.kaggle.com/discussions/product-feedback/346049ML hubstorage/kaggle-dataset-quota-request-programJSON compare report an error

Free allowance: Not a fixed number: Kaggle staff grant additional per-dataset storage quota on request via a short Google Form, explicitly to 'host large, important public datasets'.
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: email?placeholder, not evidence; card unknown, phone unknown
Binding limit: write-gatedreview, prioritised for datasets of 'general interest to our community and the ML rese
Evidence: reported2 sources; a third party said so
Freshness: stale on 2026-11-05checked 2026-10-21 (inherited); stale on 2026-11-05

Free tier	Not a fixed number: Kaggle staff grant additional per-dataset storage quota on request via a short Google Form, explicitly to 'host large, important public datasets'. This is the documented path past the 200 GB per-dataset ceiling. unit GB; metered on stored-bytes
Price	none stated
Limits	write-gated (binding) review, prioritised for datasets of 'general interest to our community and the ML rese source Human review, prioritised for datasets of 'general interest to our community and the ML research community'; not a self-service lever; no published ceiling.
Identity	email (placeholder) not published
Egress	Same free GCS-backed delivery as any other public dataset.
Per-object cap	not stated
Retention	not stated
Interface	rest rest
Tooling	Same as Kaggle Datasets. The request form is forms.gle/jh4uBjtP7CsfH97C9 (linked from the staff post).
Composes with	This is what turns 200 GB/dataset into multi-TB single objects.
Reliability	Grants are discretionary and could in principle be withdrawn, but nothing vanishes on its own.
Parsed numbers	has-free-tier 1

Evidence 2

date	source	what it proved
2026-10-21	www.kaggle.com/discussions/product-feedback/346049	Kaggle staff: 'we invite you to fill out this short Google Form ... We will prioritize granting additional storage quota for datasets that are likely to be of general interest'
2026-10-21	www.kaggle.com/discussions/product-feedback/346049	FAQ: 'Our default limits today are 200GB per dataset.'

Unknown values 4

per object cap notes: the field may be stated in a source that was not read
per object cap stated: the field may be stated in a source that was not read
retention notes: the field may be stated in a source that was not read
retention stated: the field may be stated in a source that was not read

Kaggle Models (distinct from Kaggle Datasets)

Storage

www.kaggle.com/modelsModel hubstorage/kaggle-modelsJSON compare report an error

Free allowance: 200 GB for private models, alongside 200 GB for private datasets — from Kaggle's own product announcement 'Doubling of Private Quota and Public File Size Limit': 'Users now have a limit of 200GB for private models and 200GB for private datasets.
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: emailno card, no phone
Binding limit: per-object-capFile Size Limit': 'Users now have a limit of 200GB
Evidence: reported5 sources; a third party said so
Freshness: stale on 2026-11-05checked 2026-10-21 (inherited); stale on 2026-11-05

Free tier	200 GB for private models, alongside 200 GB for private datasets — from Kaggle's own product announcement 'Doubling of Private Quota and Public File Size Limit': 'Users now have a limit of 200GB for private models and 200GB for private datasets. Kaggle has also doubled the maximum upload size of public models and datasets from 100GB to 200GB.' Public models and public datasets have a 200 GB per-item ceiling and no published aggregate cap. unit GB; metered on unstated
Price	none stated
Limits	per-object-cap (binding) File Size Limit': 'Users now have a limit of 200GB source per-object-cap 200 GB and 50 top-level files per dataset — 'A max of 50 top-level files (if you have more, use a directory structure and upload an archive)'. Uploading via the API is write-gated for most accounts. Practical caveat from the docs: archives are uncompressed server-side so their contents are usable in Notebooks, which means the 200 GB is measured on the expanded tree.
Identity	email email
Egress	Free — files come from Kaggle's Google-hosted CDN (storage.googleapis.com) with no egress meter. Downloads require a Kaggle API token.
Per-object cap	File Size Limit': 'Users now have a limit of 200GB (200000000000 bytes)
Retention	not stated
Interface	rest, git rest + git
Tooling	kagglehub and the Kaggle API. GET /api/v1/models/google/bert/get returned 200, 72,158 bytes. Datasets: /api/v1/datasets/list returns 200 JSON with totalBytesNullable per dataset. Note the upload side is narrower than the read side — 'The ability to upload models via the Kaggle API was introduced to a select group of Kaggle accounts starting in version 1.5.18', and kagglehub caps at 50 files per repo and auto-zips beyond that.
Composes with	Models and datasets are separate quota pools, so the ceiling is 200 GB private models + 200 GB private datasets + 200 GB per public model × N public models + 200 GB per public dataset × N public datasets. Public items are the real multiplier. Each model can carry multiple variations and frameworks, but they share the model's 200 GB.
Reliability	Kaggle is Google-owned and long-lived; the risk is policy drift on public storage, not disappearance. The 200 GB private pool is enforced hard ('if you exceed this, either make your datasets public or delete unused datasets').
Parsed numbers	has-free-tier 1 per-object-cap 200 GB

Evidence 5

date	source	what it proved
2026-10-21	www.kaggle.com/product-announcements/512322	opened: 'Users now have a limit of 200GB for private models and 200GB for private datasets. Kaggle has also doubled the maximum upload size of public models and datasets from 100GB to 200GB.' Both numbers on one page.
2026-10-21	www.kaggle.com/docs/datasets	opened, Technical Specifications: '200GB per dataset limit'; '200GB max private datasets (if you exceed this, either make your datasets public or delete unused datasets)'; 'A max of 50 top-level files'; archives are uncompressed on their side.
2026-10-21	www.kaggle.com/api/v1/models-onboarding-packet	surfaced: 'The ability to upload models via the Kaggle API was introduced to a select group of Kaggle accounts starting in version 1.5.18'. Read path is open, write path is not.
2026-10-21	source not published	PROBED: curl '/api/v1/models/list?search=bert&pageSize=1' -> 200, 184,016 bytes, real model objects. curl '/api/v1/models/google/bert/get' -> 200, 72,158 bytes. curl '/api/v1/datasets/list?search=titanic&pageSize=2' -> 200 with totalBytesNullable present.
2026-10-21	github.com/Kaggle/kagglehub/issues/116	opened: 'We have increased the limit on our backend to 50 files. If you are uploading more than 50 files, than kagglehub will automatically create a zip for you.' Confirms the 50-file ceiling is live.

Unknown values 3

per object cap notes: the field may be stated in a source that was not read
retention notes: the field may be stated in a source that was not read
retention stated: the field may be stated in a source that was not read

Kaggle Notebook outputs (/kaggle/working) — the free side-channel

Storage

www.kaggle.com/docs/notebooksML hubstorage/kaggle-notebook-outputs-the-free-side-channelJSON compare report an error

Free allowance: Up to 20 GB of output per notebook version saved to /kaggle/working, and every 'Save & Run All' creates a new version.
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: email?placeholder, not evidence; card unknown, phone unknown
Binding limit: noneno named constraint binds
Evidence: reported2 sources; a third party said so
Freshness: stale on 2026-11-05checked 2026-10-21 (inherited); stale on 2026-11-05

Free tier	Up to 20 GB of output per notebook version saved to /kaggle/working, and every 'Save & Run All' creates a new version. Outputs are themselves addable as dataset inputs to any future notebook. No documented cap on the number of notebook versions or notebooks per account. unit GB; metered on unstated
Price	none stated
Identity	email (placeholder) not published
Egress	Free download of notebook output files from the version's Output tab, same GCS-backed delivery.
Per-object cap	not stated
Retention	\| Outputs persist indefinitely and are downloadable years later; the flaky part is the commit step (a timed-out run loses the output).
Interface	rest, cli rest
Tooling	kaggle CLI (`kaggle kernels output <owner>/<kernel> -p ./dir`) and kagglehub; the notebook itself runs on free P100/TPU compute so the write happens server-side with no upload from a user at all.
Composes with	20 GB per notebook version. Notebook versions, notebooks and accounts each carry no stated limit. The reachable total therefore scales with versions and notebooks per account, and a second account carries a second allowance. The whole write path is server-side (the data is produced or fetched inside the notebook, so there is no client uplink bottleneck). This is the standard community alternative route around the 200 GB private quota: a Kaggle forum answer describes it as 'create a new notebook from your dataset and copy files to /kaggle/working'.
Reliability	Outputs persist indefinitely and are downloadable years later; the flaky part is the commit step (a timed-out run loses the output).
Parsed numbers	has-free-tier 1

Evidence 2

date	source	what it proved
2026-10-21	www.kaggle.com/docs/notebooks	'Up to 20 GBs of output from a Notebook may be saved to disk in /kaggle/working. This data is saved automatically and you can then reuse that data in any future Notebook'
2026-10-21	www.kaggle.com/competitions/us-patent-phrase-to-phrase-match	community: 'Use kaggle kernels to keep the datasets. It's unlimited and ofcourse free. Just create a new notebook from your dataset and copy files to /kaggle/working'

Unknown values 3

per object cap notes: the field may be stated in a source that was not read
per object cap stated: the field may be stated in a source that was not read
retention notes: the field may be stated in a source that was not read

Kaggle Notebooks + Datasets

Storage

www.kaggle.comIaaSstorage/kaggle-notebooks-datasetsJSON compare report an error

Free allowance: Notebooks: '20 Gigabytes of auto-saved disk space (/kaggle/working)' per notebook version.
Verdict: caveatusable, with a named limit or an unprobed read path
Cost: free tier
Identity: card?placeholder, not evidence; card unknown, phone unknown
Binding limit: noneno named constraint binds
Evidence: reported4 sources; a third party said so
Freshness: stale on 2026-11-05checked 2026-10-21 (inherited); stale on 2026-11-05

Free tier	Notebooks: '20 Gigabytes of auto-saved disk space (/kaggle/working)' per notebook version. Datasets: '200GB per dataset limit', '200GB max private datasets' — the 200 GB private cap is the only account-level storage number published; public datasets are capped per-dataset, not per-account. unit GB; metered on stored-bytes
Price	none stated
Identity	card (placeholder) inferred from the category 'iaas'; the source record states no identity cost, so this is a class assumption, not evidence
Egress	Public dataset/notebook downloads are served without auth and without a published egress meter.
Per-object cap	not stated
Retention	Notebook output survives session end as a versioned artifact — the closest thing here to real object storage — but it is write-once per version, and you cannot run a listener (no inbound ports, no server).
Interface	rest, rclone, cli rest
Tooling	`kaggle` CLI + REST API (`/api/v1/datasets/download/...`, `/api/v1/kernels/output/...`); `kagglehub` Python client. No rclone backend, but the CLI is scriptable and gsutil-style uploads work through the API.
Composes with	20 GB per notebook output x unlimited notebook versions (each version is an immutable snapshot, addressable and re-mountable as 'Input' in another notebook) => effectively hundreds of GB per account. Plus unlimited public datasets at 200 GB each. Both layers multiply by N free accounts.
Reliability	Notebook output survives session end as a versioned artifact — the closest thing here to real object storage — but it is write-once per version, and you cannot run a listener (no inbound ports, no server).
Parsed numbers	has-free-tier 1

Evidence 4

date	source	what it proved
2026-10-21	www.kaggle.com/docs/notebooks	'20 Gigabytes of auto-saved disk space (/kaggle/working)'; '12 hours execution time for CPU and GPU notebook sessions and 9 hours for TPU'
2026-10-21	www.kaggle.com/docs/datasets	'200GB per dataset limit'; '200GB max private datasets'
2026-10-21	www.kaggle.com/product-announcements/512322	'limit of 200GB for private models and 200GB for private datasets'; public upload size doubled to 200GB
2026-10-21	source not published	probe: GET /api/v1/datasets/download/uciml/iris?datasetVersionNumber=2 -> 302 then 200, Content-Type: application/zip, Content-Length: 3687 (anonymous, no auth)

Unknown values 3

per object cap notes: the field may be stated in a source that was not read
per object cap stated: the field may be stated in a source that was not read
retention notes: the field may be stated in a source that was not read

kaggle notebooks as a server

Storage

www.kaggle.com/docs/notebooksstorage/kaggle-notebooks-as-a-serverJSON compare report an error

Free allowance: No inbound networking and no port exposure — Kaggle notebooks cannot listen for HTTP.
Verdict: fails: quotathe free allowance is too small to matter
Cost: not stated
Identity: email?placeholder, not evidence; card unknown, phone unknown
Binding limit: noneno named constraint binds
Evidence: reported1 source; a third party said so
Freshness: stale on 2026-11-05checked 2026-10-21 (inherited); stale on 2026-11-05

Free tier	No inbound networking and no port exposure — Kaggle notebooks cannot listen for HTTP. The storage story (20 GB /kaggle/working + 200 GB datasets) is real, the CDN-origin story is not. Split unit none; metered on none
Price	none stated
Identity	email (placeholder) not published
Egress	not recorded
Interface	unknown
Tooling	not recorded

Evidence 1

date	source	what it proved
2026-10-21	www.kaggle.com/docs/notebooks	the text of Free tier, above

More fields 1

dead end	`{"failure_class": "quota","why": "No inbound networking and no port exposure — Kaggle notebooks cannot listen for HTTP. The storage story (20 GB /kaggle/working + 200 GB datasets) is real, the CDN-origin story is not. Split","retry_when": null,"first_recorded": "2026-10-21"}`

Unknown values 7

chaining: no value was recorded for this field
egress terms: no value was recorded for this field
interface: the access interface was not established
per object cap notes: no value was recorded for this field
per object cap stated: no value was recorded for this field
retention stated: no value was recorded for this field
tooling: no value was recorded for this field