Kaggle

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

Kaggle Notebooks Compute★ qualifiesany-phoneno cardphoneDvolume-quota
Kaggle Datasets (public) Storage★ qualifiesinstitutionno cardD
Kaggle Notebooks Computecaveatemail?card?Drequest-rateduplicate
Kaggle Benchmarks Computecaveatemailno cardDwrite-gated
Kaggle dataset quota-request program (the >200 GB escape hatch) Storagecaveatemail?card?Rwrite-gated
Kaggle Models (distinct from Kaggle Datasets) Storagecaveatemailno cardRper-object-cap
Kaggle Notebook outputs (/kaggle/working) — the free side-channel Storagecaveatemail?card?R
Kaggle Notebooks + Datasets Storagecaveatcard?cardR
kaggle notebooks as a server Storagefails: quotaemail?card?R

Kaggle Notebooks Compute

★ qualifiesany-phoneno cardphoneDvolume-quota

www.kaggle.com/docs/notebooks · notebook runtime · compute/kaggle-notebooks · JSON · compare

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
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
Egress	not published on the pages read: the Internet toggle governs outbound access and states no allowance and no price
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 today, 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.'
Limits	volume-quota 30 GPU hours a week, resetting weekly, sometimes higher source volume-quota 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
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 today. The notebooks page is the more specific statement, so this record carries 20 minutes and the disagreement is flagged rather than averaged.
Evidence rung	documented shape, session length, disk and the GPU quota are quoted from two first-party pages read today. The phone gate is reported, not documented; one signup would settle it.
Checked	2026-10-25 (live); stale on 2026-11-24
Parsed numbers	`$.extras.m10h_usd` price USD0.0 / month `$.extras.m24h_usd` price USD0.0 / month `$.limits[0].value` limit:volume-quota 30.0 GPU hours / week `$.limits[1].value` limit:volume-quota 12.0 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": true,
 "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 or withheld values (1)

$.egress.metered egress-unknown

Kaggle Datasets (public) Storage

★ qualifiesinstitutionno cardD

www.kaggle.com/datasets · ml-hub · storage/kaggle-datasets · JSON · compare

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
Per-object cap	not stated
Retention	not stated
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.
Identity	institution derived from the record's prose, not from an identity field, and no signup was executed: ling 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
Binding	none no constraint in the record binds at this scale; the record carries no limit of a kind the vocabulary names
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: account sahangunasekara92 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.
Notes	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).
Evidence rung	documented re-read from read-broker on 2026-10-22 (HTTP 200, 29944 bytes, sha256 1d2b0cd026b1e3a6). The page states the number in the record; the claim is documented, not measured.
Checked	2026-10-21 (inherited); stale on 2026-11-20

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 (sahangunasekara92/av2-sensor-train-group-3) same range -> 206, 104,857,600 bytes in 16.5 s = ~6.3 MB/s, anonymous
2026-10-21	withheld	probe: GET /api/v1/datasets/list?user=sahangunasekara92&pageSize=100 -> 23 public datasets, 1,197.7 GB aggregate, max 163.0 GB single dataset

More fields (1)

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

Unknown or withheld values (6)

$.evidence[5].url private-url
$.free_tier.notes process
$.per_object_cap.notes not-extracted
$.per_object_cap.stated not-extracted
$.retention.notes not-extracted
$.retention.stated not-extracted

Kaggle Notebooks Compute

caveatemail?card?Drequest-rateduplicate

www.kaggle.com/docs/notebooks · dev environment · compute/kaggle · JSON · compare

Free tier	not published unit none; metered on wall-clock; this slug exists only so a lookup for `kaggle` lands on the record
Price	none stated
Per-object cap	not stated
Retention	not stated
Egress	not stated
Identity	email (placeholder) not published
Limits	request-rate 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
Binding	request-rate
Interface	unknown
Tooling	not stated
Composes with	not stated
Reliability	no reliability event recorded
Notes	Duplicate slug. The provider's record is `kaggle-notebooks`, read on 2026-10-22. This file 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 rung	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
Checked	2026-10-23 (live); stale on 2026-11-22

Evidence (4)

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"

More fields (17)

{
 "talaria_m10h_usd": null,
 "talaria_m24h_usd": null,
 "nemo_m10h_usd": null,
 "keep_rate": null,
 "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"
 },
 "persistent_storage": null,
 "network_out": null,
 "price_note": null,
 "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"
 },
 "wave2": {
  "merged_agents": [
   "b05-gpu-free-tier"
  ],
  "merged_evidence_rows": 2,
  "merged_note": "\"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\""
 }
}

Unknown or withheld values (17)

$.chaining not-stated
$.egress.metered egress-unknown
$.egress.terms not-stated
$.evidence[0].proved process
$.extras.price_note process
$.free_tier.stated withheld
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.interface interface-unknown
$.interface_detail withheld
$.limits_note not-stated
$.per_object_cap.notes process
$.per_object_cap.stated not-stated
$.reliability_note none-observed
$.retention.notes not-extracted
$.retention.stated not-stated
$.tooling not-stated

Corrections

2026-10-22 PulsedMedia's 16 TB box was recorded twice, and one of the two is now marked as the duplicate

Kaggle Benchmarks Compute

caveatemailno cardDwrite-gated

www.kaggle.com/page/neurips-2026 · cloud VM · compute/kaggle-benchmarks · JSON · compare

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
Per-object cap	not applicable
Retention	not applicable
Egress	not stated
Identity	email not published
Limits	write-gated 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 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.
Binding	write-gated 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.
Interface	rest inferred from the tooling the provider documents; not probed
Tooling	not stated
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 dossier/compute/kaggle-notebooks.json, 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.
Evidence rung	documented
Checked	2026-10-22 (live); stale on 2026-11-21

Evidence (2)

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

More fields (1)

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

Unknown or withheld values (9)

$.egress.metered egress-unknown
$.egress.terms not-stated
$.identity_cost.detail process
$.per_object_cap.notes process
$.per_object_cap.stated not-applicable
$.reliability_note none-observed
$.retention.notes process
$.retention.stated not-applicable
$.tooling not-stated

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

caveatemail?card?Rwrite-gated

www.kaggle.com/discussions/product-feedback/346049 · ml-hub · storage/kaggle-dataset-quota-request-program · JSON · compare

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
Per-object cap	not stated
Retention	not stated
Egress	Same free GCS-backed delivery as any other public dataset.
Identity	email (placeholder) not published
Limits	write-gated 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.
Binding	write-gated the write is a queue with a person or a rule in it, so the upload rate is set by somebody else
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. Kaggle's own advice is to shard by meaningful subset, which is exactly the sharding pattern for a user needs anyway — combine: N shards x 200 GB each (no request needed) OR one request for a multi-TB dataset.
Reliability	Grants are discretionary and could in principle be withdrawn, but nothing vanishes on its own.
Notes	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.
Evidence rung	reported One page read moves it to documented.
Checked	2026-10-21 (inherited); stale on 2026-11-04

Evidence (2)

date	source	what it proved
2026-10-21	www.kaggle.com/discussions/product-feedback/346049	Kaggle staff (Meg Risdal): '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 or withheld values (7)

$.free_tier.notes process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.per_object_cap.notes not-extracted
$.per_object_cap.stated not-extracted
$.retention.notes not-extracted
$.retention.stated not-extracted

Kaggle Models (distinct from Kaggle Datasets) Storage

caveatemailno cardRper-object-cap

www.kaggle.com/models · model-hub · storage/kaggle-models · JSON · compare

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
Per-object cap	File Size Limit': 'Users now have a limit of 200GB (200000000000 bytes)
Retention	not stated
Egress	Free — files come from Kaggle's Google-hosted CDN (storage.googleapis.com) with no egress meter. Downloads require a Kaggle API token.
Identity	email email
Limits	per-object-cap 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.
Binding	per-object-cap the per-object cap sets the shard size and therefore the object count; it bounds the total more tightly than any headline quota
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').
Notes	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.
Evidence rung	reported One page read moves it to documented.
Checked	2026-10-21 (inherited); stale on 2026-11-04
Parsed numbers	`$.limits[0].value` limit:per-object-cap 200.0 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 — rule 2 in reverse.
2026-10-21	withheld	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 or withheld values (6)

$.evidence[3].url private-url
$.free_tier.notes process
$.per_object_cap.notes not-extracted
$.retention.notes not-extracted
$.retention.stated not-extracted
$.tooling partly-held

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

caveatemail?card?R

www.kaggle.com/docs/notebooks · ml-hub · storage/kaggle-notebook-outputs-the-free-side-channel · JSON · compare

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
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).
Egress	Free download of notebook output files from the version's Output tab, same GCS-backed delivery.
Identity	email (placeholder) not published
Binding	none no constraint in the record binds at this scale; the record carries no limit of a kind the vocabulary names
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 the client 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).
Notes	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.
Evidence rung	reported One page read moves it to documented.
Checked	2026-10-21 (inherited); stale on 2026-11-04

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 or withheld values (6)

$.free_tier.notes process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.per_object_cap.notes not-extracted
$.per_object_cap.stated not-extracted
$.retention.notes not-extracted

Kaggle Notebooks + Datasets Storage

caveatcard?cardR

www.kaggle.com · iaas · storage/kaggle-notebooks-datasets · JSON · compare

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
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).
Egress	Public dataset/notebook downloads are served without auth and without a published egress meter.
Identity	card (placeholder) inferred from the category 'iaas'; the source record states no identity cost, so this is a class assumption, not evidence
Binding	none no constraint in the record binds at this scale; the record carries no limit of a kind the vocabulary names
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).
Notes	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.
Evidence rung	reported One page read moves it to documented.
Checked	2026-10-21 (inherited); stale on 2026-11-04

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	withheld	probe: GET /api/v1/datasets/download/uciml/iris?datasetVersionNumber=2 -> 302 then 200, Content-Type: application/zip, Content-Length: 3687 (anonymous, no auth)

Unknown or withheld values (6)

$.evidence[3].url private-url
$.free_tier.notes process
$.identity_cost.kind identity-defaulted
$.per_object_cap.notes not-extracted
$.per_object_cap.stated not-extracted
$.retention.notes not-extracted

kaggle notebooks as a server Storage

fails: quotaemail?card?R

www.kaggle.com/docs/notebooks · rejected-provider · storage/kaggle-notebooks-as-a-server · JSON · compare

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
Per-object cap	not recorded
Retention	not recorded
Egress	not recorded
Identity	email (placeholder) not published
Binding	none no constraint of a named kind was recorded; the verdict rests on the quota sentence rather than on a named limit
Interface	unknown
Tooling	not recorded
Composes with	not recorded
Reliability	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
Notes	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
Evidence rung	reported
Checked	2026-10-21 (inherited); stale on 2026-11-04

Evidence (1)

date	source	what it proved
2026-10-21	www.kaggle.com/docs/notebooks	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

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 or withheld values (15)

$.chaining not-recorded
$.confidence_note withheld
$.egress.terms not-recorded
$.extras.dead_end.retry_when process
$.free_tier.notes process
$.identity_cost.detail defaulted
$.identity_cost.kind identity-defaulted
$.interface interface-unknown
$.interface_detail withheld
$.limits_note process
$.per_object_cap.notes not-recorded
$.per_object_cap.stated not-recorded
$.retention.notes process
$.retention.stated not-recorded
$.tooling not-recorded