Benchmarks Copy Section

Benchmarks Commands

Commands for interacting with Kaggle Benchmarks. Benchmarks let you define evaluation tasks as Python scripts, run them against one or more LLM models via the Kaggle Model Proxy, and download the results.

The top-level command is kaggle benchmarks (alias: kaggle b), which has the following subcommands and groups:

* auth — Fetch Model Proxy credentials.
* init — Fetch credentials and default environment variables for local development.
* quota — Show your Model Proxy (AI inference) spend quota.
* leaderboard — Get benchmark leaderboard information.
* tasks (alias: t) — Manage benchmark tasks (push, run, list, status, download, log, models, delete, publish).
* topics — Browse discussion topics for a benchmark.

kaggle benchmarks auth kaggle benchmarks auth')" title="Copy chapter prompt for LLMs"> Copy Chapter

Fetches a Model Proxy token and persists the credential environment variables to a file.

Usage:

kaggle benchmarks auth [options]

Options:

* -y, --yes: Automatically confirm without prompting.
* --env-file <FILE>: File to write environment variables to (default: .env).

Example:

Write Model Proxy credentials to the default .env file, confirming automatically:

kaggle b auth -y

Purpose:

This command fetches a short-lived Model Proxy API key and URL from Kaggle and appends them to your environment file. The variables written are:

* MODEL_PROXY_URL
* MODEL_PROXY_API_KEY
* MODEL_PROXY_EXPIRY_TIME

kaggle benchmarks init kaggle benchmarks init')" title="Copy chapter prompt for LLMs"> Copy Chapter

Fetches Model Proxy credentials and additional default environment variables useful for local benchmark development. Also generates a starter example task file and a syntax reference document.

Usage:

kaggle benchmarks init [options]

Options:

* -y, --yes: Automatically confirm without prompting.
* --env-file <FILE>: File to write environment variables to (default: .env).
* --example-file <FILE>: File to write the example benchmark task to (default: example_task.py).

Examples:

1. Initialize with defaults (writes .env, example_task.py, and kaggle_benchmarks_reference.md):

kaggle b init -y

2. Initialize with a custom env file and example file:

kaggle b init -y --env-file my_project/.env --example-file my_project/my_task.py

Purpose:

In addition to the three credential variables written by auth, init also writes:

* LLM_DEFAULT — Default model slug for tasks.
* LLM_DEFAULT_EVAL — Default model slug for evaluation.
* LLMS_AVAILABLE — Comma-separated list of available model slugs.

init also creates two files alongside the example file:

* example_task.py (or custom name via --example-file) — A starter Python script demonstrating how to define a benchmark task using @task decorators and the kaggle_benchmarks library.
* kaggle_benchmarks_reference.md — A syntax reference document for the kaggle-benchmarks task API.

If either file already exists, it is skipped without overwriting.

---

kaggle benchmarks quota kaggle benchmarks quota')" title="Copy chapter prompt for LLMs"> Copy Chapter

Shows your current Model Proxy (AI inference) spend quota, one row per refill period.

Usage:

kaggle benchmarks quota [options]

Options:

* -v, --csv: Print results in CSV format.
* --format <FORMAT>: Print results in the selected format (csv, table, json).

Example:

$ kaggle b quota
period   used    remaining  total    refillAt
-------  ------  ---------  -------  -------------------------
Daily    $1.20   $3.80      $5.00    2026-08-08T00:00:00+00:00
Monthly  $14.50  $85.50     $100.00  2026-09-01T00:00:00+00:00

Purpose:

Amounts are in USD and reflect inference spend through the Model Proxy — this is separate from the top-level kaggle quota command, which reports weekly GPU and TPU accelerator hours. remaining is derived as total - used and is clamped at $0.00, so an overage shows as zero remaining rather than a negative balance.

---

kaggle benchmarks leaderboard kaggle benchmarks leaderboard')" title="Copy chapter prompt for LLMs"> Copy Chapter

Get benchmark leaderboard information.

Usage:

kaggle benchmarks leaderboard <BENCHMARK> [options]

Arguments:

* <BENCHMARK>: Benchmark slug (e.g., owner/benchmark-slug).

Options:

* --version <VERSION>: Benchmark version (optional).
* -s, --show: Show the leaderboard in the terminal.
* -d, --download: Download the leaderboard as a CSV file.
* -p, --path <DIRECTORY>: Folder where the leaderboard will be downloaded (defaults to current working directory).
* -v, --csv: Print results in CSV format (when used with --show).
* --format <FORMAT>: Print results in a specific format (e.g., json).

Examples:

1. Show the leaderboard for a benchmark:

kaggle b leaderboard owner/my-benchmark --show

2. Download the leaderboard as CSV:

kaggle b leaderboard owner/my-benchmark --download

3. Show a specific version of the leaderboard in JSON format:

kaggle b leaderboard owner/my-benchmark --version 2 --show --format json

Purpose:

Displays or downloads the evaluation results for all models that have run tasks in the specified benchmark. The leaderboard is represented as a table where rows are model versions and columns are benchmark tasks, showing the score achieved by each model on each task.

---

Tasks Commands Copy Chapter

All tasks commands live under kaggle benchmarks tasks (alias: kaggle b t).

Task Name Format Copy Section

Task arguments (<TASK>) support two formats:

* Bare slug (my-task): Refers to a task owned by the current user.
* Owner prefix (owner/my-task): Refers to a specific owner's task (e.g., another user's public task, or your-username/my-task).

| Command Group | Supported Formats | Description |
|---|---|---|
| View & Run (run, status, download, log) | my-task, owner/my-task | Interact with your own tasks or public tasks from other users |
| Publish (publish) | my-task, your-username/my-task | Make your own task public (must be task owner) |
| Create (push) | my-task only | Must match the @task(name="...") decorator in your Python source file |

Slug Normalization: Task names are automatically converted to URL-safe slugs (My Task → my-task). For owner/task arguments, each segment is slugified independently (Owner/My Task → owner/my-task) so the / separator is preserved.

kaggle benchmarks tasks push kaggle benchmarks tasks push')" title="Copy section prompt for LLMs"> Copy Section

Creates or updates a benchmark task from a local Python source file. The file must contain at least one function decorated with @task.

Usage:

kaggle benchmarks tasks push <TASK> -f <FILE> [options]

Arguments:

* <TASK>: Task name. Automatically normalized to a URL-safe slug (e.g., my_task or My Task becomes my-task).

Options:

-f, --file <FILE> (required)*: Path to the source Python file defining the task.
* --wait [TIMEOUT]: Wait for the task creation to complete. Optionally specify a timeout in seconds (0 or omit value = wait indefinitely).
* --poll-interval <SECONDS>: Maximum seconds between status polls (default: 60). Polling starts at 5s and increases by 50% each iteration until reaching this value.
* -v, --verbose: Enable verbose polling logs.
* -d, --kaggle-dataset <DATASET>: Kaggle dataset to attach to the task's underlying notebook (format: owner/dataset-slug). Repeat for multiple datasets (e.g. -d kaggle/titanic -d user/my-dataset). Mounted at /kaggle/input/<dataset-slug>/ by default. If a naming conflict occurs, the fully qualified mount path /kaggle/input/<owner>/<dataset-slug>/ is used instead.

Examples:

1. Push a task and return immediately:

kaggle b t push my-task -f benchmark.py

2. Push a task and wait for creation to finish:

kaggle b t push my-task -f benchmark.py --wait

3. Push a task and wait with a 60-second timeout, polling every 5 seconds:

kaggle b t push my-task -f benchmark.py --wait 60 --poll-interval 5

kaggle b t push my-task -f benchmark.py -d kaggle/titanic -d user/my-dataset

kaggle b t push my-task -f benchmark.py --wait -d kaggle/titanic

Purpose:

This command reads a .py file, converts it to a Jupyter notebook format, and uploads it to Kaggle as a benchmark task. If a task with the same slug already exists, a new version is created. The file is validated to ensure it contains a @task decorator matching the given task name.

---

kaggle benchmarks tasks run kaggle benchmarks tasks run')" title="Copy section prompt for LLMs"> Copy Section

Runs a previously pushed task against one or more models.

Usage:

kaggle benchmarks tasks run <TASK> [options]

Arguments:

* <TASK>: Task name (slug, e.g. my-task or owner/my-task).

Options:

* -m, --model <MODEL>: Model slug (e.g. gemini-2.5-pro) to run against. Repeat for multiple models (e.g. -m gemini-2.5-pro -m claude-sonnet-4). If omitted, an interactive model picker is displayed.
* --wait [TIMEOUT]: Wait for runs to complete. Optionally specify a timeout in seconds (0 or omit value = wait indefinitely).
* --poll-interval <SECONDS>: Maximum seconds between status polls (default: 60). Polling starts at 5s and increases by 50% each iteration until reaching this value.
* -v, --verbose: Enable verbose polling logs.

Examples:

1. Run a task with interactive model selection:

kaggle b t run my-task

2. Run a task against specific models:

kaggle b t run my-task -m gemini-2.5-pro -m claude-sonnet-4

3. Run a task and wait for all runs to finish:

kaggle b t run my-task -m gemini-2.5-pro --wait

Purpose:

This command schedules benchmark runs on the server. The task must be in a COMPLETED creation state before it can be run. If no models are specified, the CLI presents a paginated list of available models for interactive selection.

---

kaggle benchmarks tasks list kaggle benchmarks tasks list')" title="Copy section prompt for LLMs"> Copy Section

Lists benchmark tasks owned by the current user.

Usage:

kaggle benchmarks tasks list [options]

Options:

* --name-regex <REGEX>: Filter task names by regular expression.
* --status <STATUS>: Filter tasks by creation status. Valid values: queued, running, completed, errored.

Examples:

1. List all your tasks:

kaggle b t list

2. List only completed tasks whose names contain "gemini":

kaggle b t list --name-regex gemini --status completed

Purpose:

Displays a table of your benchmark tasks showing the task slug, current version (or unset if unavailable), creation status, and creation timestamp.

---

kaggle benchmarks tasks status kaggle benchmarks tasks status')" title="Copy section prompt for LLMs"> Copy Section

Shows task details and per-model run status.

Usage:

kaggle benchmarks tasks status <TASK> [options]

Arguments:

* <TASK>: Task name (slug, e.g. my-task or owner/my-task).

Options:

* -m, --model <MODEL>: Filter the run table to a specific model slug (e.g. gemini-2.5-pro). Repeat for multiple models.

Examples:

1. Show full status for a task:

kaggle b t status my-task

2. Show status for another user's task:

kaggle b t status someuser/their-task

3. Show status for specific models only:

kaggle b t status my-task -m gemini-2.5-pro

Purpose:

Prints the task's metadata (slug, creation status, creation time, URL) followed by a table of all runs. Each run row shows the model name, run state, start time, and end time. Any errored runs display their error messages below the table.

If task creation itself failed, the Status: line shows the failure kind — the cleaned creation-state enum, titlecased (e.g. Kernel_Without_Run, No_Model_Specified, Validation_Failed, Errored) — and an Error: line is appended below it with the server-provided creation_error_message explaining what went wrong.

---

kaggle benchmarks tasks download kaggle benchmarks tasks download')" title="Copy section prompt for LLMs"> Copy Section

Downloads output files for completed benchmark runs.

Usage:

kaggle benchmarks tasks download <TASK> [options]

Arguments:

* <TASK>: Task name (slug, e.g. my-task or owner/my-task).

Options:

* -m, --model <MODEL>: Download outputs only for a specific model slug (e.g. gemini-2.5-pro). Repeat for multiple models.
* -o, --output <DIRECTORY>: Directory to download output files into (defaults to current working directory).
* -s, --include-source: Also download the kernel session's source notebooks.
* -f, --force: Force re-download of already completed runs, overwriting local files.

Examples:

1. Download all completed run outputs for a task:

kaggle b t download my-task

2. Download outputs from another user's public task:

kaggle b t download someuser/their-task

3. Download outputs for a specific model into a custom directory:

kaggle b t download my-task -m gemini-2.5-pro -o ./results

4. Download outputs with source notebooks included:

kaggle b t download my-task --include-source

5. Force re-download of previously downloaded runs:

kaggle b t download my-task --force

Purpose:

Downloads and extracts the output zip archive for each completed run. Files are organized in a hierarchical layout that includes the task's version number (or unset if unavailable):

<output>/<task>/<version>/<model>/<run_id>/
   ├── output files...

Progress is rendered as a table with one row per run:

Model                File                                     Size       Progress
──────────────────── ──────────────────────────────────────── ────────── ──────────
gemini-2.5-pro       gemini-2.5-pro/12345/                    1.24MB     Done
claude-sonnet-4      claude-sonnet-4/12346/                   2.10MB     Cached

The Size column reports the extracted on-disk size of the run's output directory. The Progress column is one of Done (freshly downloaded), Cached (output directory already on disk from a previous download), or Bad zip (downloaded archive was corrupt).

Already-downloaded runs (where the output directory exists) are automatically skipped — they appear as Cached rows — unless the -f / --force flag is used, in which case they are overwritten.

When --include-source is used, the downloaded zip also contains the kernel session's source files (e.g., __notebook__.ipynb and __notebook_source__.ipynb).

If you re-run with -s after a previous download that omitted source notebooks, the cached directories are not re-fetched and the -s flag is effectively ignored. The CLI detects this and prints a tip after the summary:

Tip: 2 cached run(s) lack source notebooks. Re-run with -f -s to fetch them.

Use -f -s together to force re-download and backfill the source notebooks into the cached runs.

---

kaggle benchmarks tasks log kaggle benchmarks tasks log')" title="Copy section prompt for LLMs"> Copy Section

Get execution logs for benchmark task run(s).

Usage:

kaggle benchmarks tasks log <TASK> [options]

Arguments:

* <TASK>: Task name (slug, e.g. my-task or owner/my-task).

Options:

* -m, --model <MODEL>: Filter logs to a specific model slug (e.g. gemini-2.5-pro). Repeat for multiple models. If omitted, logs for all runs are shown.

Aliases: log, logs

Examples:

1. Show logs for all runs of a task:

kaggle b t log my-task

2. Show logs for another user's task:

kaggle b t log someuser/their-task

3. Show logs for a specific model's run(s):

kaggle b t log my-task -m gemini-2.5-pro

4. Show logs for multiple models:

kaggle b t logs my-task -m gemini-2.5-pro -m claude-sonnet-4

Purpose:

Fetches and displays execution logs for benchmark task runs. Each run's logs are printed with a structured header and footer for clear identification:

═══ Logs for gemini-2.5-pro (Run 123) [COMPLETED] ═══
<log output>
═══ (42 lines) ═══
═══ Logs for claude-sonnet-4 (Run 456) [ERRORED] ═══
<log output>
═══ (18 lines) ═══
Showed logs for 2 run(s) across 2 model(s).

* Header: Shows model name, run ID, and run state (COMPLETED, ERRORED, RUNNING, etc.).
* Footer: Shows the line count for each run's log output.
* Summary: Printed at the end with total run and model counts.

The command handles two response types from the server:

* Active runs: Logs are streamed in real-time via Server-Sent Events (SSE).
* Completed runs: The persisted log file is returned and printed.

Concurrency & Streaming Order Copy Section

When viewing logs for multiple concurrent model runs, the CLI processes and outputs them sequentially to prevent logs from interleaving and garbling your terminal output:
1. The CLI prints the header for the first model run in the queue.
2. If that run is currently active, the CLI blocks and streams its log output in real-time via SSE until it completes.
3. The log output for the next model run will only be printed once the previous model run's log stream finishes and closes.
4. Any model runs that complete in the background while you are watching the first stream will print instantly as completed persisted logs once their turn in the sequence is reached.

Model Slug Normalization Copy Section

Benchmark model names are automatically normalized on both input and output. This makes it easy to pass various formats interchangeably while keeping displays and directories clean.

* Flexible Inputs: The CLI accepts model names in several formats:
* Canonical Slugs (recommended): gemini-2.5-pro or claude-sonnet-4
* With Provider Prefix: google/gemini-2.5-pro or anthropic/claude-sonnet-4
* With Version/Proxy @ symbols: anthropic/claude-haiku-4-5@20251001 or claude-sonnet-4-6@default
* Unified Normalization: The client automatically strips any provider prefix (e.g., google/ or anthropic/) and replaces @ characters with - to match the server's canonical database slug format.
* Clean Outputs:
* Status Display: Tables and error logs display the canonical, hyphenated slugs (e.g., claude-haiku-4-5-20251001 and gemini-2.0-flash-lite-001) for readability.
* Hierarchical Downloads: Run outputs are extracted into clean folders using the canonical slugs (e.g., ./<task>/<version>/claude-haiku-4-5-20251001/<run_id>/), with no @ or / symbols in folder names.

---

kaggle benchmarks tasks models kaggle benchmarks tasks models')" title="Copy section prompt for LLMs"> Copy Section

Lists all available benchmark models.

Usage:

kaggle benchmarks tasks models

Example:

kaggle b t models

Purpose:

Prints a table of all models available for benchmark runs, showing each model's slug and display name. This is useful for discovering valid model slugs to pass to run, status, or download commands.

---

kaggle benchmarks tasks delete kaggle benchmarks tasks delete')" title="Copy section prompt for LLMs"> Copy Section

Removes a benchmark task.

Usage:

kaggle benchmarks tasks delete <TASK> [options]

Arguments:

* <TASK>: Task name (slug, e.g. my-task or owner/my-task).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

kaggle b t delete my-task -y

Purpose:

Deletes a benchmark task and all associated runs. Note: This command is not yet supported by the server.

---

kaggle benchmarks tasks publish kaggle benchmarks tasks publish')" title="Copy section prompt for LLMs"> Copy Section

kaggle benchmarks tasks publish <TASK> [options]

kaggle b t publish my-task

kaggle b t publish my-task --no-publish-backing-notebook

kaggle benchmarks topics list kaggle benchmarks topics list')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics for a benchmark.

Usage:

kaggle benchmarks topics list <BENCHMARK> [options]

Arguments:

* <BENCHMARK>: Benchmark slug (e.g., kaggle/chess).

Options:

* --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* -s, --search <SEARCH_TERM>: Search query to filter topics.
* --page-size <PAGE_SIZE>: Number of items per page.
* --page-token <PAGE_TOKEN>: Page token for pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle benchmarks topics list kaggle/chess

Purpose:

This command lets you browse discussion topics for a specific benchmark.

kaggle benchmarks topics show kaggle benchmarks topics show')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a benchmark discussion topic with all comments in tree form.

Usage:

kaggle benchmarks topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <benchmark>/<topic-id> (e.g., kaggle/chess/614080 - note that this supports multi-slash benchmark slugs)
* <benchmark> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle benchmarks topics show kaggle/chess/614080

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

---

Competition Creation Copy Section

Hosting a Competition from the CLI

This page documents the host-facing commands added in kaggle-cli for the new
public competition-creation API endpoints (kagglesdk 0.1.31+):

- kaggle competitions init
- kaggle competitions create
- kaggle competitions pages create
- kaggle competitions hosts
- kaggle competitions host-add
- kaggle competitions settings get
- kaggle competitions settings update
- kaggle competitions data update
- kaggle competitions solution create
- kaggle competitions solution status
- kaggle competitions launch

All of these commands require an authenticated session
(kaggle config set username/password or an API token).

A typical end-to-end host workflow looks like:

1. Scaffold a metadata file.

kaggle competitions init ./my-comp
2. Edit ./my-comp/competition-metadata.json (fill in the INSERT_* placeholders).
3. Create the (unlaunched) competition.

kaggle competitions create -p ./my-comp
→ Competition created: https://www.kaggle.com/competitions/my-comp-slug
4. Author the description and rules pages.

kaggle competitions pages create my-comp-slug --name description -f ./description.md --publish
kaggle competitions pages create my-comp-slug --name rules -f ./rules.md --publish
5. Update the competition data (train.csv, test.csv, sample_submission.csv, ...).

kaggle competitions data update my-comp-slug -p ./data -m "Initial release"
6. Upload the private solution CSV, then poll until scoring is ready.

kaggle competitions solution create my-comp-slug -p ./solution.csv
kaggle competitions solution status my-comp-slug
→ Ready: true
7. Optionally tune host-only settings not covered by competition-metadata.json

   (deadlines, runtime caps, leaderboard behavior, etc.).

kaggle competitions settings get my-comp-slug
kaggle competitions settings update my-comp-slug -f ./settings.json
8. Launch the competition (now, or schedule a future UTC time).

kaggle competitions launch my-comp-slug --at 2027-01-01T00:00:00Z

These commands are independent — for example, you can call pages create
on a competition that already exists, or use launch on a competition created
via the host wizard.

---

kaggle competitions init kaggle competitions init')" title="Copy chapter prompt for LLMs"> Copy Chapter

Writes a competition-metadata.json template into a folder.

Usage:

kaggle competitions init [folder]

Arguments:

- folder (optional): Where to write competition-metadata.json. Defaults to
the current directory.

Example:

kaggle competitions init ./my-comp

The generated file:

{
  "title": "INSERT_TITLE_HERE",
  "slug": "INSERT_SLUG_HERE",
  "briefDescription": "INSERT_BRIEF_DESCRIPTION_HERE",
  "privacy": "PUBLIC",
  "disableKernels": false,
  "hackathon": false,
  "cloneCompetitionId": null,
  "cloneExcludeCompetitionData": null,
  "clonePageNames": null,
  "licenseId": null,
  "organizationId": null,
  "numPrizes": null,
  "restrictLinkToEmailList": null,
  "reward": null
}

See Metadata reference below for what each
field means.

---

kaggle competitions create kaggle competitions create')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new competition from competition-metadata.json. The competition is
created in an unlaunched (staged) state — use
kaggle competitions launch to publish it.

Usage:

kaggle competitions create [-p folder]

Options:

- -p, --path <folder>: Folder containing competition-metadata.json. Defaults
to the current directory.

Example:

kaggle competitions create -p ./my-comp
→ Competition created: https://www.kaggle.com/competitions/my-comp-slug

Errors you might see:

- Default title detected, please update competition-metadata.json before creating
— you forgot to replace one of the INSERT_*_HERE placeholders.
- Invalid privacy '...' — privacy must be one of PUBLIC, LIMITED, PRIVATE.
- Metadata file not found: competition-metadata.json — run init first, or pass
-p pointing at the folder that contains the file.

Competition metadata reference Copy Section

All fields go in competition-metadata.json (camelCase keys).

Required:

| Field | Type | Notes |
|---|---|---|
| title | string | Display title shown on the competition page. |
| slug | string | URL slug; lowercase, hyphens, must be unique site-wide and must not be all digits or all hyphens. |
| briefDescription | string | One-line subtitle under the title. |
| privacy | string | One of PUBLIC, LIMITED, PRIVATE. |

Optional:

| Field | Type | Notes |
|---|---|---|
| disableKernels | bool | If true, notebook submissions are disabled. |
| hackathon | bool | Create as a hackathon competition. |
| restrictLinkToEmailList | bool | Restrict invite-link joiners to a host-maintained allowlist. |
| cloneCompetitionId | int | If set, clone configuration / pages / data / evaluation setup from this competition. |
| cloneExcludeCompetitionData | bool | If cloning, skip copying the data (solution, sandbox submissions, images, databundles). |
| clonePageNames | string[] | If cloning, copy only these page names. Omit/null to copy all. |
| licenseId | int | License ID for the competition data. |
| organizationId | int | Tie this competition to an organization (read-only access for all org members). |
| numPrizes | int | Number of leaderboard prize positions. |
| reward | object | See below. |

reward object:

{
  "id": "USD",
  "quantity": 25000,
  "clarification": "Total prize pool split across the top 5 teams."
}

reward.id is one of: USD, KUDOS, AUD, EUR, JOBS, SWAG, GBP,
KNOWLEDGE, PRIZES. clarification is optional free-form text shown next to
the prize.

---

kaggle competitions pages create kaggle competitions pages create')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new page (description, rules, evaluation, data-description, etc.) on a
competition you host.

Usage:

kaggle competitions pages create <competition> --page-name <page-name> -f <path> \
    [--mime-type <type>] [--post-title "<title>"] [--publish]

Arguments:

- <competition>: The competition slug.

Options:

- --page-name <page-name> (required): Page name (e.g. description, rules,
evaluation, data-description, prizes). Conventional names are
recognized by the competition page UI; new names are allowed but won't be
shown in the standard tabs.
- -f, --file <path> (required): Path to a file whose contents become the page
body.
- --mime-type <type> (optional): MIME type of the content. Defaults to
text/html server-side.
- --post-title "<title>" (optional): Title shown above the page body.
Defaults to the page name.
- --publish (optional): Publish the page immediately. Without this flag the
page is created in a staged (unpublished) state so you can review it before
going live.

Example:

Create the rules page in a staged (not-yet-published) state.

kaggle competitions pages create my-comp --page-name rules -f ./rules.md \
    --mime-type text/markdown --post-title "Competition Rules"
When you're ready to make it visible to participants:

kaggle competitions pages update my-comp --page-name rules --publish

Each page exists as a single record; --publish / --unpublish toggles its
visibility rather than creating separate draft and live copies. To swap in new
content later, use
kaggle competitions pages update — a
second create for the same page name will be rejected.

You can list and inspect existing pages with kaggle competitions pages
(or the explicit kaggle competitions pages list), modify one in place with
kaggle competitions pages update, or
remove one with kaggle competitions pages delete.

---

kaggle competitions pages update kaggle competitions pages update')" title="Copy chapter prompt for LLMs"> Copy Chapter

Updates fields on an existing competition page. Only the flags you supply are
sent (the FieldMask is built from which arguments are non-default), so this is
also how you publish or unpublish a page in place.

Usage:

kaggle competitions pages update <competition> --page-name <current-name> \
    [-f <path>] [--new-name <name>] [--mime-type <type>] \
    [--post-title "<title>"] [--publish | --unpublish]

Arguments:

- <competition>: The competition slug.

Options:

- --page-name <current-name> (required): The page's current name (used as the
identifier; rename via --new-name).
- -f, --file <path> (optional): Path to a file with the new page body.
- --new-name <name> (optional): Rename the page.
- --mime-type <type> (optional): New MIME type of the content.
- --post-title "<title>" (optional): New title shown above the page content.
- --publish / --unpublish (optional, mutually exclusive): Publish or
unpublish the page.

At least one update flag is required.

Examples:

Publish a staged page without changing its content.

kaggle competitions pages update my-comp --page-name rules --publish
Swap in new content and update the visible title in one call.

kaggle competitions pages update my-comp --page-name rules \
    -f ./rules-v2.md --post-title "Competition Rules (v2)"
Rename a page.

kaggle competitions pages update my-comp --page-name evaluation \
    --new-name scoring

Note: a small set of pages is reserved by the backend and cannot be
renamed; attempting to rename one returns an error from the server.

---

kaggle competitions pages delete kaggle competitions pages delete')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a page from a competition you host. Prompts for confirmation unless
-y/--yes is passed (matches the existing kaggle datasets delete /
kaggle kernels delete patterns).

Usage:

kaggle competitions pages delete <competition> --page-name <name> [-y]

Arguments:

- <competition>: The competition slug.

Options:

- --page-name <name> (required): Name of the page to delete.
- -y, --yes (optional): Skip the confirmation prompt — useful for scripts.

Examples:

Interactive: prompts "Are you sure you want to delete the page 'faq' ...?"

kaggle competitions pages delete my-comp --page-name faq
Scripted: skip the prompt.

kaggle competitions pages delete my-comp --page-name faq -y

Note: a small set of pages is protected by the backend and cannot be
deleted; attempting to delete one returns an error from the server.

Deletion is not recoverable — there is no "undelete". List pages first with
kaggle competitions pages list <competition> if you're unsure of the name.

---

kaggle competitions hosts kaggle competitions hosts')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists the hosts (users with host access) for a competition. Useful for
confirming who can edit settings, upload data, or launch — especially after
adding or removing collaborators via the web UI.

Usage:

kaggle competitions hosts <competition> [-v | --format json]

Arguments:

- <competition>: The competition slug.

Examples:

Table output.

kaggle competitions hosts my-comp
CSV — useful for piping into other tools.

kaggle competitions hosts my-comp -v
JSON.

kaggle competitions hosts my-comp --format json

Output columns: userName, displayName, id, profileUrl.

---

kaggle competitions host-add kaggle competitions host-add')" title="Copy chapter prompt for LLMs"> Copy Chapter

Grants host access on a competition you host to another Kaggle user. Hosts can
edit settings, upload data, and launch the competition, so you are asked to
confirm before the change is made.

Usage:

kaggle competitions host-add <competition> -u <user> [-y]

Arguments:

- <competition>: The competition slug.

Options:

- -u, --user <USER>: Kaggle user name (URL slug, e.g. kerneler) of the user
to add as a host. Required.
- -y, --yes: Skip the confirmation prompt.
- -q, --quiet: Suppress the "Using competition" message.

Examples:

Prompts for confirmation before granting access.

kaggle competitions host-add my-comp -u alice
Skip the prompt (for scripts).

kaggle competitions host-add my-comp -u alice -y

Verify the result with kaggle competitions hosts my-comp.

Note: This command is named host-add rather than hosts add because

hosts takes the competition as a positional argument, and argparse cannot

distinguish a competition slug from a subcommand name.

---

kaggle competitions settings get kaggle competitions settings get')" title="Copy chapter prompt for LLMs"> Copy Chapter

Shows the unified settings blob for a competition you host — the same set of
fields the "Settings" tab exposes in the web UI, covering general info,
access & teams, key dates, submissions & leaderboard behavior, code
competition parameters, and host attribution.

By default the output is grouped by UI section and hides fields left at their
type default (unset strings, false booleans, zero ints). Pass --json for
the raw blob (camelCase keys, matching the update payload format).

Usage:

kaggle competitions settings get <competition> [--json]

Arguments:

- <competition>: The competition slug.

Examples:

Grouped, human-readable summary.

kaggle competitions settings get my-comp
Machine-readable dump — pipe into jq, or save + edit + feed back to update.

kaggle competitions settings get my-comp --json > settings.json

---

kaggle competitions settings update kaggle competitions settings update')" title="Copy chapter prompt for LLMs"> Copy Chapter

Applies a partial update to a competition's settings. You author a JSON or
YAML file containing only the fields you want to change; the CLI builds the
server-side FieldMask from the keys present in the file, so unspecified
fields are left alone.

The typical loop is:

1. kaggle competitions settings get my-comp --json > settings.json — pull
the current values.
2. Edit the file down to just the fields you want to change (delete the rest).
3. kaggle competitions settings update my-comp -f ./settings.json.

Usage:

kaggle competitions settings update <competition> -f <path> [--json]

Arguments:

- <competition>: The competition slug.

Options:

- -f, --from-file <path> (required): JSON or YAML file with the fields to
update. Extension picks the parser (.yaml/.yml → YAML, anything else →
JSON). Keys may be snake_case (matches the SDK) or camelCase (matches
the --json output of settings get).
- --json (optional): After the update, print the returned settings as JSON
instead of the grouped text view.

Examples:

Toggle a single boolean:

// disable-leaderboard.json
{ "has_leaderboard": false }

kaggle competitions settings update my-comp -f ./disable-leaderboard.json

Set the competition deadline:

// deadline.json
{ "deadline": "2027-02-01T23:59:00Z" }

kaggle competitions settings update my-comp -f ./deadline.json

Bump the code-competition runtime caps and set the competition and team-merger
deadlines (YAML, mixing types):

tune.yaml

max_cpu_runtime_minutes: 540
max_gpu_runtime_minutes: 720
deadline: 2027-02-01T23:59:00Z
team_merger_explicit_deadline: 2027-01-15T00:00:00Z
rules_required: true

kaggle competitions settings update my-comp -f ./tune.yaml

Type notes:

- Booleans → JSON true/false (or YAML equivalents).
- Numeric fields → plain numbers (240, 1.5).
- Datetime fields → ISO-8601 strings ("2027-01-01T00:00:00Z" or with an
explicit offset).
- Enum fields (host_segment, publicly_cloneable) → the enum member name
as a string; either the full name ("HOST_SEGMENT_FEATURED") or the short
suffix ("FEATURED") works.

Common errors:

- Unknown competition setting: '<name>' — the field name isn't in
CompetitionSettings. Check settings get --json for the exact keys.
- Field '<name>' expects a bool, got str — the file has a string where a
boolean is required (e.g. "true" instead of true).
- not a valid HostSegment. Allowed: ... — the enum value you passed isn't
a member; the error lists the accepted names.
- Some settings are gated to Kaggle admins (marked "ADMIN ONLY" in the
proto — e.g. host_segment, directly_responsible_user_id) and the server
will reject writes to them for non-admin hosts.

---

kaggle competitions launch kaggle competitions launch')" title="Copy chapter prompt for LLMs"> Copy Chapter

Launches a competition you host. Without --at, the competition is launched
immediately. With --at, the backend schedules the launch for the given UTC
instant.

Usage:

kaggle competitions launch <competition> [--at <ISO-8601 UTC>]

Arguments:

- <competition>: The competition slug.

Options:

- --at <iso>: Schedule launch for a future UTC time. Accepts ISO-8601
(e.g. 2027-01-01T00:00:00Z or 2027-01-01T00:00:00+00:00). The competition
is launched immediately if omitted.

Examples:

Launch right now.

kaggle competitions launch my-comp
Schedule the launch for midnight UTC on 2027-01-01.

kaggle competitions launch my-comp --at 2027-01-01T00:00:00Z

A competition can only be launched once. Subsequent calls will be rejected by
the backend.

---

kaggle competitions data update kaggle competitions data update')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new version of the data files for a competition you host. Uploads
via the standard blob-upload pipeline, then sends a single request bundling
the uploaded tokens. Each update replaces the prior version's file set in
full — there is no per-file "keep from previous" mode in v1, so list every
file you want in the new version.

Usage:

kaggle competitions data update <competition> -p <path> -m "<version notes>" \
    [--rerun] [--include-hidden] [--ignore-patterns <patterns>]

Arguments:

- <competition>: The competition slug.

Options:

- -p, --path <path> (required): Either a directory (walked recursively —
every file becomes an upload with its relative path preserved in the API's
name field, e.g. train/images/img1.jpg), or a single archive file
(e.g. a pre-packed .zip or .tar) uploaded as-is. Sub-directories are
always traversed; hidden entries (see --include-hidden) are the only files
skipped by default.
- -m, --message "<notes>" (required): Notes describing this version
(e.g. "Added test set").
- --rerun (optional): Update the RERUN databundle — the private host-only
data swapped in during rerun scoring. Requires Kaggle admin access for now.
Without this flag, the update targets the PUBLIC databundle (what
participants download).
- --include-hidden (optional): Upload hidden files and traverse hidden
sub-directories (names starting with . — e.g. .DS_Store, .git/,
.gitignore). Skipped by default so you don't accidentally publish OS
metadata or version-control detritus.
- --ignore-patterns <patterns> (optional): Patterns to ignore when uploading files/dirs. Can be specified multiple times. Note that default ignore patterns (like .git/, .cache/, .huggingface/) are bypassed when --include-hidden is True.

Examples:

Update using a directory tree (recurses into sub-folders).

kaggle competitions data update my-comp -p ./data -m "Initial release"
Update using a pre-packed archive as a single file (useful when you already

need a zip for other purposes, or for directory-shaped file formats like

Zarr).

kaggle competitions data update my-comp -p ./data.zip -m "Initial release"
New version with a bug-fix.

kaggle competitions data update my-comp -p ./data -m "Fix label encoding in train.csv"
Update the private rerun-scoring data.

kaggle competitions data update my-comp -p ./rerun-data \
    -m "Held-out test set" --rerun

A note on directory-shaped file formats: some formats (Zarr, some
TensorFlow SavedModel layouts, etc.) are on-disk directories that are logically
a single unit. If you pass a directory containing such a format, the recursive
walk uploads each internal chunk as its own file — often what you want for
Zarr, since participants can then stream individual chunks. If you'd rather
keep the format as an opaque single upload, pre-pack it into a .zip or
.tar and pass that file to -p instead.

The command prints the public URL plus the new databundle_id and
databundle_version_id on success.

---

kaggle competitions solution create kaggle competitions solution create')" title="Copy chapter prompt for LLMs"> Copy Chapter

Uploads the private solution CSV for a competition you host. The solution is
what the backend scores submissions against — one row per row in the sample
submission, with the same column shape. After uploading, the backend runs
preprocessing / sampling; poll
kaggle competitions solution status
until it's ready before opening submissions.

The file is uploaded via the standard blob-upload pipeline, then the resulting
token is passed to CreateCompetitionSolution.

Usage:

kaggle competitions solution create <competition> -p <path> [-q]

Arguments:

- <competition>: The competition slug.

Options:

- -p, --path <path> (required): Path to a single CSV file. Must be a single
file — directories are rejected. The CSV shape must match a submission
file (same columns as sample_submission.csv).
- -q, --quiet (optional): Suppress per-file upload progress lines.

Example:

kaggle competitions solution create my-comp -p ./solution.csv
→ Solution uploaded for "my-comp". Run 'kaggle competitions solution status my-comp' to check readiness.

Re-uploading a solution replaces the prior one. Note that this only works
pre-launch; after launch the solution file is frozen.

---

kaggle competitions solution status kaggle competitions solution status')" title="Copy chapter prompt for LLMs"> Copy Chapter

Shows the setup status for a competition's solution file — whether
preprocessing/sampling has finished, any errors reported by the backend, and
(for legacy C# metrics) the auto-inferred column mapping and required metric
columns.

Poll this after solution create (and after data update — some setup steps
run against the databundle) until Ready: true. If Setup error: is set,
stop polling and fix the underlying issue.

Usage:

kaggle competitions solution status <competition> [--json]

Arguments:

- <competition>: The competition slug.

Options:

- --json (optional): Emit the raw status as JSON instead of the
human-readable view.

Examples:

Human-readable summary.

kaggle competitions solution status my-comp
→ Ready: true

  Solution file: solution.csv — 12.3KB — uploaded 2027-01-01T00:00:00+00:00

    total=1000, public=300, private=700
Machine-readable — useful in a polling loop.

kaggle competitions solution status my-comp --json

Fields you might see (human view):

- Ready: true|false — whether scoring is unblocked.
- Setup error: <msg> — populated if preprocessing failed. Surfaced
prominently; stop polling when it appears.
- Kernels metric: true — the competition's scoring metric is a Kernels
metric. Kernels metrics auto-detect their column mapping; the host only
needs to wait for Ready to flip true.
- Row ID column: <name> — for Kernels metrics, the auto-detected row-id
column.
- Solution file: <name> — <size> — uploaded <timestamp> and
total=..., public=..., private=... — solution file metadata once the
upload is processed.
- Column mapping: — for legacy C# metrics, the current mapping from metric
column name to CSV column name.
- Required columns: — for legacy C# metrics, the metric column slots the
host needs to fill (name + expected data type).

---

Competitions Copy Section

Competitions Commands

Commands for interacting with Kaggle competitions.

For tutorials on how to submit to competitions :
* How to Submit to a Competition
* How to Submit to a Code Competition

kaggle competitions list kaggle competitions list')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists available competitions.

Usage:

kaggle competitions list [options]

Options:

* --group <GROUP>: Filter by competition group. Valid options: general, entered, inClass.
* --category <CATEGORY>: Filter by competition category. Valid options: all, featured, research, recruitment, gettingStarted, masters, playground.
* --sort-by <SORT_BY>: Sort results. Valid options: grouped, prize, earliestDeadline, latestDeadline, numberOfTeams, recentlyCreated (default: latestDeadline).
* -p, --page <PAGE>: Page number for results (default: 1).
* -s, --search <SEARCH_TERM>: Search term.
* -v, --csv: Print results in CSV format.
* --format: Output format (csv, table, json, or a field projection). See output_format.md.

Output columns:

ref, deadline, category, reward, teamCount, userHasEntered, userRank

userRank is your public leaderboard position when you have entered the competition. It is 0 when you have not entered, or when no public rank is available yet.

Example:

List featured competitions in the general group, sorted by prize:

kaggle competitions list --group general --category featured --sort-by prize

List entered competitions with rank in CSV format:

kaggle competitions list --group entered -v

Purpose:

This command helps you discover new competitions or find specific ones based on various criteria. Use --group entered to see your rank across competitions you have joined.

kaggle competitions files kaggle competitions files')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists files for a specific competition.

Usage:

kaggle competitions files <COMPETITION> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., titanic).

Options:

* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.
* --page-token <PAGE_TOKEN>: Page token for results paging.
* --page-size <PAGE_SIZE>: Number of items to show on a page (default: 20, max: 200).

Example:

List the first 3 files for the "titanic" competition in CSV format, quietly:

kaggle competitions files titanic --page-size=3 -v -q

Purpose:

Use this command to see the data files available for a competition before downloading them.

kaggle competitions download kaggle competitions download')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads competition files.

Usage:

kaggle competitions download <COMPETITION> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., titanic).

Options:

* -f, --file <FILE_NAME>: Specific file to download (downloads all if not specified).
* -p, --path <PATH>: Folder to download files to (defaults to current directory).
* -w, --wp: Download files to the current working path (equivalent to -p .).
* -o, --force: Force download, overwriting existing files.
* -q, --quiet: Suppress verbose output.

Examples:

1. Download all files for the "titanic" competition to the current directory, overwriting existing files, quietly:

kaggle competitions download titanic -w -o -q

2. Download the test.csv file from the "titanic" competition to a folder named tost:

kaggle competitions download titanic -f test.csv -p tost

Purpose:

This command allows you to get the necessary data files for a competition onto your local machine.

kaggle competitions submit kaggle competitions submit')" title="Copy chapter prompt for LLMs"> Copy Chapter

Makes a new submission to a competition.

Usage:

kaggle competitions submit <COMPETITION> -f <FILE_NAME> -m <MESSAGE> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., house-prices-advanced-regression-techniques).
* -f, --file <FILE_NAME>: The submission file.
* -m, --message <MESSAGE>: The submission message.

Options:

* -k, --kernel <KERNEL>: Name of the kernel (notebook) to submit (for code competitions).
* -v, --version <VERSION>: Version of the kernel to submit (e.g. 2).
* -q, --quiet: Suppress verbose output.
* --sandbox: Mark submission as a sandbox submission (competition hosts/admins only).
* --wait [SECONDS]: Wait for the submission to finish scoring, printing the public score when done. Optionally pass a timeout in seconds (0 or no value = wait up to 12 hours, the maximum notebook runtime). Exits non-zero if scoring fails or the timeout is reached.
* --poll-interval <SECONDS>: Maximum seconds between status polls while waiting (default: 60, minimum: 5). Polling starts at 5s and increases automatically.

On a successful submission the command prints the numeric submission ref, e.g. Submission ref: 12345678. You can look that submission up later with kaggle competitions submission.

Example: Standard (not code) competition:

Submit sample_submission.csv to the "house-prices-advanced-regression-techniques" competition with the message "Test message":

kaggle competitions submit house-prices-advanced-regression-techniques -f sample_submission.csv -m "Test message"

Example: Code competition:

Submit the submission.csv produced by version 3 of your <YOUR_USERNAME>/rsna-submission for the rsna-2024-lumbar-spine-degenerative-classification competition:

kaggle competitions submit rsna-2024-lumbar-spine-degenerative-classification -f submission.csv -k <YOUR_USERNAME>/rsna-submission -v 3 -m "Test message"

Example: Submit and wait for the score (useful in CI):

Submit and block until scoring finishes (up to a 10-minute timeout), then print the public score:

kaggle competitions submit house-prices-advanced-regression-techniques -f sample_submission.csv -m "CI run" --wait 600

The command exits 0 once the submission is scored and non-zero if scoring fails or the timeout is reached, so it can gate a pipeline.

Purpose:

Use this command to upload your predictions or code to a competition for scoring.

kaggle competitions submission kaggle competitions submission')" title="Copy chapter prompt for LLMs"> Copy Chapter

Shows the status and score of a single submission by its numeric ref (as printed by kaggle competitions submit).

Usage:

kaggle competitions submission <SUBMISSION_REF>

Arguments:

* <SUBMISSION_REF>: The numeric submission ref printed by kaggle competitions submit.

Example:

kaggle competitions submission 12345678

Output:

Submission Ref:  12345678
Status:          COMPLETE
Public Score:    0.98765
Private Score:
Description:     Test message
Submission Date: 2026-07-19 12:00:00

Purpose:

Use this command to check whether a submission has finished scoring and to read its public score — for example, after submitting without --wait, or from a script polling for results.

kaggle competitions submissions kaggle competitions submissions')" title="Copy chapter prompt for LLMs"> Copy Chapter

Shows your past submissions for a competition.

Usage:

kaggle competitions submissions <COMPETITION> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., house-prices-advanced-regression-techniques).

Options:

* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

Show submissions for "house-prices-advanced-regression-techniques" in CSV format, quietly:

kaggle competitions submissions house-prices-advanced-regression-techniques -v -q

Purpose:

This command allows you to review your previous submission attempts and their scores.

kaggle competitions submission-download kaggle competitions submission-download')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads the submitted file for a single submission by its numeric id.

Usage:

kaggle competitions submission-download <SUBMISSION_ID> [options]

Arguments:

* <SUBMISSION_ID>: The numeric submission id printed by kaggle competitions submit, or listed by kaggle competitions submissions <COMPETITION>.

Options:

* -p, --path <PATH>: Folder to download the file to. Defaults to the current working directory's Kaggle download location.
* -o, --force: Download even if a local copy already exists (skips the up-to-date check).
* -q, --quiet: Suppress verbose output.

Example:

Download the file for submission 12345678 into ./subs:

kaggle competitions submission-download 12345678 -p ./subs

Purpose:

Use this command to retrieve the exact file you (or a teammate) submitted — for example, to inspect an old submission or reproduce a scored result.

kaggle competitions leaderboard kaggle competitions leaderboard')" title="Copy chapter prompt for LLMs"> Copy Chapter

Gets competition leaderboard information.

Usage:

kaggle competitions leaderboard <COMPETITION> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., titanic).

Options:

* -s, --show: Show the top of the leaderboard in the console.
* -d, --download: Download the entire leaderboard to a CSV file.
* -p, --path <PATH>: Folder to download the leaderboard to (if -d is used).
* -v, --csv: Print results in CSV format (used with -s).
* -q, --quiet: Suppress verbose output.

Examples:

1. Download the "titanic" leaderboard to a folder named leaders, quietly:

kaggle competitions leaderboard titanic -d -p leaders -q

2. Download the leaderboard and save it to leaderboard.txt:

kaggle competitions leaderboard titanic > leaderboard.txt

Purpose:

This command lets you view your ranking and the scores of other participants in a competition.

kaggle competitions topics list kaggle competitions topics list')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics for a competition.

Usage:

kaggle competitions topics list [COMPETITION] [options]

Note: kaggle competitions topics (without list subcommand) is supported as a shortcut to list topics for the default competition (configured via kaggle config set competition).

Arguments:

* [COMPETITION]: Competition URL suffix (e.g., titanic). Optional if default competition is configured.

Options:

* -s, --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* --search <SEARCH>: Search query to filter topics.
* --page-size <PAGE_SIZE>: Number of items to show on a page. Default is 20, max is 200.
* --page-token <PAGE_TOKEN>: Page token for results paging.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List discussion topics for the "titanic" competition sorted by most recent:

kaggle competitions topics list titanic -s recent

Purpose:

This command lets you browse discussion topics for a specific competition.

kaggle competitions topics show kaggle competitions topics show')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a competition discussion topic with all comments in tree form.

Usage:

kaggle competitions topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <competition>/<topic-id> (e.g., titanic/12345)
* <competition> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

Show topic 12345 from the "titanic" competition:

kaggle competitions topics show titanic/12345

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

kaggle competitions topic-messages kaggle competitions topic-messages')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists messages within a competition discussion topic.

Deprecated: This command is deprecated in favor of kaggle competitions topics show. It will be removed in a future release.

Usage:

kaggle competitions topic-messages <COMPETITION> <TOPIC_ID> [options]

Arguments:

* <COMPETITION>: Competition URL suffix (e.g., titanic).
* <TOPIC_ID>: The discussion topic id.

Options:

* -s, --sort-by <SORT_BY>: Sort order. Valid options: best, new, old.
* -n, --page-size <PAGE_SIZE>: Max top-level messages to return; -1 for all.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List all messages for topic 12345 in the "titanic" competition, sorted by newest first:

kaggle competitions topic-messages titanic 12345 -s new -n -1

Purpose:

This command displays the messages within a specific competition discussion topic.

---

Configuration Copy Section

Kaggle CLI Configuration

The Kaggle CLI uses a configuration file to store settings such as your API credentials and default values for commands.

Configuration Commands Copy Chapter

config view config view')" title="Copy section prompt for LLMs"> Copy Section

Displays the current configuration values.

Usage:

kaggle config view

Purpose:

This command allows you to inspect the current settings of your Kaggle CLI, such as the configured API endpoint, proxy settings, and default competition.

config set config set')" title="Copy section prompt for LLMs"> Copy Section

Sets a specific configuration value.

Usage:

kaggle config set -n <NAME> -v <VALUE>

Arguments:

* -n, --name <NAME>: The name of the configuration parameter to set. Valid options are competition, path, and proxy.
* -v, --value <VALUE>: The value to set for the configuration parameter.
* For competition: The competition URL suffix (e.g., titanic).
* For path: The default folder where files will be downloaded.
* For proxy: The proxy server URL.

Example:

Set the default competition to "titanic":

kaggle config set -n competition -v titanic

Purpose:

Use this command to customize the behavior of the Kaggle CLI, such as setting a default competition to avoid specifying it in every command, defining a default download path, or configuring a proxy server.

config unset config unset')" title="Copy section prompt for LLMs"> Copy Section

Clears a specific configuration value, reverting it to its default.

Usage:

kaggle config unset -n <NAME>

Arguments:

* -n, --name <NAME>: The name of the configuration parameter to clear. Valid options are competition, path, and proxy.

Example:

Clear the default competition:

kaggle config unset -n competition

Purpose:

This command removes a previously set configuration value, allowing the CLI to use its default behavior or prompt for the value if required.

Configuration File Location Copy Chapter

The Kaggle CLI configuration is typically stored in a file named kaggle.json located in the ~/.kaggle/ directory on Linux and macOS, or C:\Users\<Windows-username>\.kaggle\ on Windows.

This file contains your API username and key:

{"username":"YOUR_USERNAME","key":"YOUR_API_KEY"}

You can download this file from your Kaggle account page (https://www.kaggle.com/<YOUR_USERNAME>/account) and place it in the correct directory.

Alternatively, you can set the KAGGLE_USERNAME and KAGGLE_KEY environment variables.

---

Datasets Copy Section

Datasets Commands

Commands for interacting with Kaggle datasets.

kaggle datasets list kaggle datasets list')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists available datasets.

Usage:

kaggle datasets list [options]

Options:

* --sort-by <SORT_BY>: Sort results. Valid options: hottest, votes, updated, active (default: hottest).
* --size <SIZE_CATEGORY>: DEPRECATED. Use --min-size and --max-size.
* --file-type <FILE_TYPE>: Filter by file type. Valid options: all, csv, sqlite, json, bigQuery.
* --license <LICENSE_NAME>: Filter by license. Valid options: all, cc, gpl, odb, other.
* --tags <TAG_IDS>: Filter by tags (comma-separated tag IDs).
* -s, --search <SEARCH_TERM>: Search term.
* -m, --mine: Display only your datasets.
* --user <USER>: Filter by a specific user or organization.
* -p, --page <PAGE>: Page number for results (default: 1).
* -v, --csv: Print results in CSV format.
* --max-size <BYTES>: Maximum dataset size in bytes.
* --min-size <BYTES>: Minimum dataset size in bytes.

Examples:

1. List your own datasets:

kaggle datasets list -m

2. List CSV datasets, page 2, sorted by last updated, containing "student" in their title, with size between 13000 and 15000 bytes:

kaggle datasets list --file-type csv --page 2 --sort-by updated -s student --min-size 13000 --max-size 15000

3. List datasets with an ODB license, tagged with "internet", and matching the search term "telco":

kaggle datasets list --license odb --tags internet --search telco

Purpose:

This command helps you find datasets on Kaggle based on various criteria like owner, file type, tags, and size.

kaggle datasets files kaggle datasets files')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists files for a specific dataset.

Usage:

kaggle datasets files <DATASET> [options]

Arguments:

* <DATASET>: Dataset URL suffix in the format owner/dataset-name (e.g., kerneler/brazilian-bird-observation-metadata-from-wikiaves).

Options:

* -v, --csv: Print results in CSV format.
* --page-token <PAGE_TOKEN>: Page token for results paging.
* --page-size <PAGE_SIZE>: Number of items to show on a page (default: 20, max: 200).

Example:

List the first 7 files for the dataset kerneler/brazilian-bird-observation-metadata-from-wikiaves:

kaggle datasets files kerneler/brazilian-bird-observation-metadata-from-wikiaves --page-size=7

Purpose:

Use this command to see the individual files within a dataset before downloading.

kaggle datasets download kaggle datasets download')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads dataset files.

Usage:

kaggle datasets download <DATASET> [options]

Arguments:

* <DATASET>: Dataset URL suffix (e.g., willianoliveiragibin/pixar-films).

Options:

* -f, --file <FILE_NAME>: Specific file to download (downloads all if not specified).
* -p, --path <PATH>: Folder to download files to (defaults to current directory).
* -w, --wp: Download files to the current working path.
* --unzip: Unzip the downloaded file (deletes the .zip file afterwards).
* -o, --force: Force download, overwriting existing files.
* -q, --quiet: Suppress verbose output.

Examples:

1. Download all files for the dataset willianoliveiragibin/pixar-films:

kaggle datasets download -d willianoliveiragibin/pixar-films

2. Download the dataset goefft/public-datasets-with-file-types-and-columns, unzip it into the tmp folder, overwriting if necessary, and suppress output:

kaggle datasets download goefft/public-datasets-with-file-types-and-columns -p tmp --unzip -o -q

3. Download the specific file dataset_results.csv from goefft/public-datasets-with-file-types-and-columns to the current working directory, quietly, and force overwrite:

kaggle datasets download goefft/public-datasets-with-file-types-and-columns -f dataset_results.csv -w -q -o

Purpose:

This command allows you to retrieve dataset files for local use.

kaggle datasets init kaggle datasets init')" title="Copy chapter prompt for LLMs"> Copy Chapter

Initializes a metadata file (dataset-metadata.json) for creating a new dataset. See metadata file format.

Usage:

kaggle datasets init -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: The path to the folder where the dataset-metadata.json file will be created (defaults to the current directory).

Example:

Initialize a dataset metadata file in the tests/dataset folder:

kaggle datasets init -p tests/dataset

Purpose:

This command creates a template dataset-metadata.json file that you need to edit before creating a new dataset on Kaggle. This file contains information like the dataset title, ID (slug), and licenses.

kaggle datasets create kaggle datasets create')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new dataset on Kaggle.

Usage:

kaggle datasets create -p <FOLDER_PATH> [options]

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the data files and the dataset-metadata.json file (defaults to the current directory).
* -u, --public: Make the dataset public (default is private).
* -q, --quiet: Suppress verbose output.
* -t, --keep-tabular: Do not convert tabular files to CSV (default is to convert).
* -r, --dir-mode <MODE>: How to handle directories: skip (ignore), zip (compressed upload), tar (uncompressed upload) (default: skip).
* --ignore-patterns <PATTERNS>: Patterns of files/dirs to ignore. Can be specified multiple times.

Example:

Create a new public dataset from the files in tests/dataset, quietly, without converting tabular files, and skipping subdirectories. (Assumes dataset-metadata.json in tests/dataset has been properly edited with title and slug):

Example: Edit dataset-metadata.json first

sed -i 's/INSERT_TITLE_HERE/My Dataset Title/' tests/dataset/dataset-metadata.json

sed -i 's/INSERT_SLUG_HERE/my-dataset-slug/' tests/dataset/dataset-metadata.json
kaggle datasets create -p tests/dataset --public -q -t -r skip

Purpose:

This command uploads your local data files and the associated metadata to create a new dataset on Kaggle.

kaggle datasets version kaggle datasets version')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new version of an existing dataset.

Usage:

kaggle datasets version -p <FOLDER_PATH> -m <VERSION_NOTES> [options]

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the updated data files and dataset-metadata.json (defaults to current directory).
* -m, --message <VERSION_NOTES>: (Required) Message describing the new version.
* -q, --quiet: Suppress verbose output.
* -t, --keep-tabular: Do not convert tabular files to CSV.
* -r, --dir-mode <MODE>: Directory handling mode (skip, zip, tar).
* -d, --delete-old-versions: Delete old versions of this dataset.
* --ignore-patterns <PATTERNS>: Patterns of files/dirs to ignore. Can be specified multiple times.

Example:

Create a new version of a dataset using files from tests/dataset with version notes "Updated data", quietly, keeping tabular formats, skipping directories, and deleting old versions:

kaggle datasets version -m "Updated data" -p tests/dataset -q -t -r skip -d

Purpose:

Use this command to update an existing dataset with new files or metadata changes.

kaggle datasets metadata kaggle datasets metadata')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads metadata for a dataset or updates existing from local metadata.

Usage:

kaggle datasets metadata <DATASET> [options]

Arguments:

* <DATASET>: Dataset URL suffix (e.g., goefft/public-datasets-with-file-types-and-columns).

Options:

* -p, --path <PATH>: Directory to download/update metadata file (dataset-metadata.json). Defaults to current working directory.
* --update: Update the existing dataset version's metadata using the contents of the local metadata JSON file. (e.g. "push" from local)

Example:

Download metadata for the dataset goefft/public-datasets-with-file-types-and-columns into the tests/dataset folder:

kaggle datasets metadata goefft/public-datasets-with-file-types-and-columns -p tests/dataset

Purpose:

This command allows you to fetch the dataset-metadata.json file for an existing dataset, which can be useful for inspection or as a template for creating a new version.

kaggle datasets status kaggle datasets status')" title="Copy chapter prompt for LLMs"> Copy Chapter

Gets the creation status of a dataset.

Usage:

kaggle datasets status <DATASET>

Arguments:

* <DATASET>: Dataset URL suffix (e.g., goefft/public-datasets-with-file-types-and-columns).

Example:

Get the status of the dataset goefft/public-datasets-with-file-types-and-columns:

kaggle datasets status goefft/public-datasets-with-file-types-and-columns

Purpose:

After creating or updating a dataset, this command helps you check if the process was successful or if there were any issues.

kaggle datasets delete kaggle datasets delete')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a dataset from Kaggle.

Usage:

kaggle datasets delete <DATASET> [options]

Arguments:

* <DATASET>: Dataset URL suffix (e.g., username/dataset-slug).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

Delete the dataset username/dataset-slug and automatically confirm:

kaggle datasets delete username/dataset-slug --yes

Purpose:

This command permanently removes one of your datasets from Kaggle. Use with caution.

kaggle datasets topics list kaggle datasets topics list')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics for a dataset.

Usage:

kaggle datasets topics list <DATASET> [options]

Arguments:

* <DATASET>: Dataset ref in format <owner>/<dataset-slug> (e.g., zillow/zecon).

Options:

* --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* -s, --search <SEARCH_TERM>: Search query to filter topics.
* --page-size <PAGE_SIZE>: Number of items per page.
* --page-token <PAGE_TOKEN>: Page token for pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List recent topics for the zillow/zecon dataset:

kaggle datasets topics list zillow/zecon --sort-by recent

Purpose:

This command lets you browse discussion topics for a specific dataset.

kaggle datasets topics show kaggle datasets topics show')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a dataset discussion topic with all comments in tree form.

Usage:

kaggle datasets topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <dataset>/<topic-id> (e.g., zillow/zecon/12345 - note that this supports multi-slash dataset slugs)
* <dataset> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle datasets topics show zillow/zecon/12345

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

---

Datasets Metadata Copy Section

The Kaggle API follows the Data Package specification for specifying metadata when creating new Datasets and Dataset versions. Next to your files, you have to put a special dataset-metadata.json file in your upload folder alongside the files for each new Dataset (version).

Here's a basic example for dataset-metadata.json:
``
{
"title": "My Awesome Dataset",
"id": "timoboz/my-awesome-dataset",
"licenses": [{"name": "CC0-1.0"}]
}
`
You can also use the API command kaggle datasets init -p /path/to/dataset to have the API create this file for you.

Here's an example containing file metadata:
`
{
"title": "My Awesome Dataset",
"subtitle": "My awesomer subtitle",
"description": "My awesomest description",
"id": "timoboz/my-awesome-dataset",
"id_no": 12345,
"licenses": [{"name": "CC0-1.0"}],
"resources": [
{
"path": "my-awesome-data.csv",
"description": "This is my awesome data!",
"schema": {
"fields": [
{
"name": "StringField",
"description": "String field description",
"type": "string"
},
{
"name": "NumberField",
"description": "Number field description",
"type": "number"
},
{
"name": "DateTimeField",
"description": "Date time field description",
"type": "datetime"
}
]
}
},
{
"path": "my-awesome-extra-file.txt",
"description": "This is my awesome extra file!"
}
],
"keywords": [
"beginner",
"tutorial"
],
"expectedUpdateFrequency": "monthly",
"userSpecifiedSources": "World Bank and OECD (link)",
"image": "relative/path/to/new/image.png"
}
`



Contents Copy Chapter

kaggle forums ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists all discussion forums. Also available as kaggle forums list.

Alias: f

Usage:

kaggle forums [options]

Options:

* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List all forums in CSV format:

kaggle forums -v

Purpose:

This command helps you discover all available discussion forums on Kaggle.

kaggle forums topics list ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics in a forum.

Usage:

kaggle forums topics list [FORUM] [options]

Note: kaggle forums topics (without list subcommand) is supported as a shortcut to list all topics (without forum filtering).

Arguments:

* [FORUM]: Forum slug (e.g., 1, product-feedback). Optional.

Options:

* --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* -s, --search <SEARCH_TERM>: Search query to filter topics.
* --category <CATEGORY>: Filter by category. Valid options: all, forums, competitions, datasets, competition_write_ups, models, benchmarks.
* --group <GROUP>: Filter by group. Valid options: all, owned, upvoted, bookmarked, my_activity, drafts.
* --page-size <PAGE_SIZE>: Number of items per page.
* --page-token <PAGE_TOKEN>: Page token for pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List topics in the "getting-started" forum sorted by most recent, showing 5 per page:

kaggle forums topics list getting-started --sort-by recent --page-size 5

Purpose:

This command lets you browse discussion topics within a specific forum, with filtering and sorting options.

kaggle forums topics show ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a topic with all comments in tree form (indented).

Usage:

kaggle forums topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <forum-name>/<topic-id> (e.g., getting-started/12345)
* <forum-name> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

Show topic 12345 from the "getting-started" forum:

kaggle forums topics show getting-started/12345

Show the same topic using two separate arguments:

kaggle forums topics show getting-started 12345

Show a topic by bare numeric ID:

kaggle forums topics show 12345

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

---

Index Copy Section

.. _kaggle:

.. kaggle-cli documentation master file, created by
sphinx-quickstart on Thu Jun 26 22:53:21 2025.
You can adapt this file completely to your liking, but it should at least
contain the root toctree directive.

kaggle-cli documentation
========================

.. toctree::
:maxdepth: 2
:caption: Contents:

intro
configuration
competitions
competition_creation
datasets
kernels
models
model_instances
model_instances_versions
benchmarks
search
tutorials

---

Kernels Copy Section

Kernels Commands

Commands for interacting with Kaggle Kernels (notebooks and scripts).

kaggle kernels list ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists available kernels.

Usage:

kaggle kernels list [options]

Options:

* -m, --mine: Display only your kernels.
* -p, --page <PAGE>: Page number for results (default: 1).
* --page-size <SIZE>: Number of items per page (default: 20).
* -s, --search <SEARCH_TERM>: Search term.
* -v, --csv: Print results in CSV format.
* --parent <PARENT_KERNEL>: Filter by parent kernel (format: owner/kernel-slug).
* --competition <COMPETITION_SLUG>: Filter by competition.
* --dataset <DATASET_SLUG>: Filter by dataset (format: owner/dataset-slug).
* --user <USER>: Filter by a specific user.
* --language <LANGUAGE>: Filter by language (all, python, r, sqlite, julia).
* --kernel-type <TYPE>: Filter by kernel type (all, script, notebook).
* --output-type <TYPE>: Filter by output type (all, visualizations, data).
* --sort-by <SORT_BY>: Sort results (hotness, commentCount, dateCreated, dateRun, relevance, scoreAscending, scoreDescending, viewCount, voteCount). Default: hotness.

Examples:

1. List your own kernels containing "Exercise" in the title, page 2, 5 items per page, in CSV format, sorted by run date:

kaggle kernels list -m -s Exercise --page-size 5 -p 2 -v --sort-by dateRun

2. List kernels that are children of $KAGGLE_DEVELOPER/exercise-lists (replace $KAGGLE_DEVELOPER with your username):

kaggle kernels list --parent $KAGGLE_DEVELOPER/exercise-lists

3. List the first 5 kernels for the "house-prices-advanced-regression-techniques" competition:

kaggle kernels list --competition house-prices-advanced-regression-techniques --page-size 5

4. List the first 5 kernels associated with the dataset dansbecker/home-data-for-ml-course:

kaggle kernels list --dataset dansbecker/home-data-for-ml-course --page-size 5

5. List Python notebooks by user $KAGGLE_DEVELOPER that output data:

kaggle kernels list --user $KAGGLE_DEVELOPER --language python --kernel-type notebook --output-type data

Purpose:

This command allows you to find kernels based on various filters like ownership, associated competition/dataset, language, or type.

kaggle kernels files ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists output files for a specific kernel.

Usage:

kaggle kernels files <KERNEL> [options]

Arguments:

* <KERNEL>: Kernel URL suffix (format: owner/kernel-slug, e.g., kerneler/sqlite-global-default).

Options:

* -v, --csv: Print results in CSV format.
* --page-token <PAGE_TOKEN>: Page token for results paging.
* --page-size <PAGE_SIZE>: Number of items to show on a page (default: 20, max: 200).

Example:

List the first output file for the kernel kerneler/sqlite-global-default in CSV format:

kaggle kernels files kerneler/sqlite-global-default -v --page-size=1

Purpose:

Use this command to view the files generated by a kernel run.

kaggle kernels init ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Initializes a metadata file (kernel-metadata.json) for a new or existing kernel. See metadata file format.

Usage:

kaggle kernels init -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: The path to the folder where the kernel-metadata.json file will be created (defaults to the current directory).

Example:

Initialize a kernel metadata file in the tests/kernel folder:

kaggle kernels init -p tests/kernel

Purpose:

This command creates a template kernel-metadata.json file. You need to edit this file with details like the kernel's title, ID (slug), language, kernel type, and data sources before pushing it to Kaggle.

kaggle kernels push ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Pushes new code/notebook and metadata to a kernel, then runs the kernel.

Usage:

kaggle kernels push -p <FOLDER_PATH> [options]

Options:

* --accelerator <ACCELERATOR_ID>: ID name of the accelerator to use during the run. E.g. "NvidiaTeslaP100" (aka default GPU), "NvidiaTeslaT4", "TpuV6E8".
* -p, --path <FOLDER_PATH>: Path to the folder containing the kernel file (e.g., .ipynb, .Rmd, .py) and the kernel-metadata.json file (defaults to the current directory).
* -t, --timeout <SECONDS>: Maximum run time in seconds.

Example:

Push the kernel from the tests/kernel folder (assuming it contains the kernel file and kernel-metadata.json):

kaggle kernels push -p tests/kernel

Purpose:

This command uploads your local kernel file and its metadata to Kaggle. If the kernel specified in the metadata exists under your account, it will be updated. Otherwise, a new kernel will be created. After uploading, Kaggle will attempt to run the kernel.

Accelerators available as of Feb 2026:

* NvidiaTeslaP100
* TpuV38
* NvidiaTeslaT4
* NvidiaTeslaT4Highmem
* Tpu1VmV38
* NvidiaTeslaA100
* NvidiaL4
* TpuV5E8
* NvidiaL4X1
* TpuV6E8
* NvidiaH100
* NvidiaRtxPro6000

Some of these are only available to participants of specific competitions, and some are only available to Kaggle admins.

kaggle kernels pull ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Pulls down the code/notebook and metadata for a kernel.

Usage:

kaggle kernels pull <KERNEL> [options]

Arguments:

* <KERNEL>: Kernel URL suffix (format: owner/kernel-slug or owner/kernel-slug/version, e.g., $KAGGLE_DEVELOPER/exercise-as-with or $KAGGLE_DEVELOPER/exercise-as-with/2).

Options:

* -p, --path <PATH>: Folder to download files to (defaults to current directory).
* -w, --wp: Download files to the current working path.
* -m, --metadata: Generate a kernel-metadata.json file along with the kernel code.

Examples:

1. Pull the kernel $KAGGLE_DEVELOPER/exercise-as-with and its metadata into the tests/kernel folder:

kaggle kernels pull -p tests/kernel $KAGGLE_DEVELOPER/exercise-as-with -m

2. Pull the kernel $KAGGLE_DEVELOPER/exercise-as-with into the current working directory:

kaggle kernels pull --wp $KAGGLE_DEVELOPER/exercise-as-with

3. Pull version 2 of the kernel $KAGGLE_DEVELOPER/exercise-as-with into the current working directory:

kaggle kernels pull --wp $KAGGLE_DEVELOPER/exercise-as-with/2

Purpose:

This command allows you to download the source code and optionally the metadata of a kernel from Kaggle to your local machine.

kaggle kernels output ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Gets the data output from the latest run of a kernel.

Usage:

kaggle kernels output <KERNEL> [options]

Arguments:

* <KERNEL>: Kernel URL suffix (e.g., kerneler/using-google-bird-vocalization-model).

Options:

* -p, --path <PATH>: Folder to download output files to (defaults to current directory).
* -w, --wp: Download files to the current working path.
* -o, --force: Force download, overwriting existing files.
* -q, --quiet: Suppress verbose output.
* --file-pattern <REGEX>: Regex pattern to match against filenames. Only files matching the pattern will be downloaded.
* --page-size <SIZE>: Number of output files to request per page. Default size is 20, max is 200.
* --page-token <TOKEN>: Download files from a specific output page. If Kaggle returns another page token, it is printed after the download.

Example:

Download the output of the kernel kerneler/using-google-bird-vocalization-model, forcing overwrite:

kaggle kernels output kerneler/sqlite-global-default -o

kaggle kernels output <kernel> --file-pattern ".*\.png$"  # Only PNG files

kaggle kernels output <kernel> --file-pattern ".*\.png$"

kaggle kernels output <kernel> --page-token <TOKEN>

kaggle kernels output <kernel> --page-size 50

Use this command to retrieve the files generated by a kernel run, such as submission files, processed data, or visualizations. By default, output downloads scan every available output page, so --file-pattern can match files beyond the first page. Use --page-size to control how many files are requested on each page, and use --page-token when you only want to download files from one specific page.

kaggle kernels status ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays the status of the latest run of a kernel.

Usage:

kaggle kernels status <KERNEL>

Arguments:

* <KERNEL>: Kernel URL suffix (e.g., kerneler/sqlite-global-default).

Example:

Get the status of the kernel kerneler/sqlite-global-default:

kaggle kernels status kerneler/sqlite-global-default

Purpose:

This command tells you whether the latest run of your kernel is still running, completed successfully, or failed.

kaggle kernels delete ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a kernel from Kaggle.

Usage:

kaggle kernels delete <KERNEL> [options]

Arguments:

* <KERNEL>: Kernel URL suffix (format: owner/kernel-slug, e.g., $KAGGLE_DEVELOPER/exercise-delete).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

Delete the kernel $KAGGLE_DEVELOPER/exercise-delete and automatically confirm:

kaggle kernels delete $KAGGLE_DEVELOPER/exercise-delete --yes

Purpose:

This command permanently removes one of your kernels from Kaggle. Use with caution.

kaggle kernels topics list ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics for a kernel.

Usage:

kaggle kernels topics list <KERNEL> [options]

Arguments:

* <KERNEL>: Kernel ref in format <owner>/<kernel-slug> (e.g., owner/kernel-slug).

Options:

* --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* -s, --search <SEARCH_TERM>: Search query to filter topics.
* --page-size <PAGE_SIZE>: Number of items per page.
* --page-token <PAGE_TOKEN>: Page token for pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

List recent topics for the owner/kernel-slug kernel:

kaggle kernels topics list owner/kernel-slug --sort-by recent

Purpose:

This command lets you browse discussion topics for a specific kernel.

kaggle kernels topics show ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a kernel discussion topic with all comments in tree form.

Usage:

kaggle kernels topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <kernel>/<topic-id> (e.g., owner/kernel-slug/12345)
* <kernel> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle kernels topics show owner/kernel-slug/12345

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

Using Secrets in Kernels Copy Chapter

If your kernel needs to access sensitive information (like API keys or passwords) without exposing them in your code, you should use Kaggle Secrets.

1. Define Secrets on Kaggle.com (no CLI support) Copy Section

from kaggle_secrets import UserSecretsClient
Retrieve the secret value using the label you defined

secret_value = UserSecretsClient().get_secret("MY_API_KEY")

Note: The kaggle_secrets package is pre-installed and only functional within the Kaggle notebook execution environment. It will not work when running scripts locally.

---

Kernels Metadata Copy Section

To upload and run a kernel, a special kernel-metadata.json file must be specified.

Here's a basic example for kernel-metadata.json:
`
{
"id": "timoboz/my-awesome-kernel",
"id_no": 12345,
"title": "My Awesome Kernel",
"code_file": "my-awesome-kernel.ipynb",
"language": "python",
"kernel_type": "notebook",
"is_private": "false",
"enable_gpu": "false",
"enable_internet": "false",
"machine_shape": "",
"dataset_sources": ["timoboz/my-awesome-dataset"],
"competition_sources": [],
"kernel_sources": [],
"model_sources": []
}
`
You can also use the API command kaggle kernels init -p /path/to/kernel to have the API create this file for you for a new kernel. If you wish to get the metadata for an existing kernel, you can use kaggle kernels pull -p /path/to/download -k username/kernel-slug -m.



Contents Copy Chapter

kaggle models variations init ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Initializes a metadata file (model-instance-metadata.json) for creating a new model variation.
Note that the name of the file reflects the old name for a variation, which was "instance".

Usage:

kaggle models variations init -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: The path to the folder where the model-instance-metadata.json file will be created (defaults to the current directory).

Example:

Initialize a model variation metadata file in the tmp folder:

kaggle models variations init -p tmp

Purpose:

This command creates a template model-instance-metadata.json file. You must edit this file with details such as the owner slug, the parent model slug, the variation (or instance) slug (URL-friendly name for this variations), and the framework (e.g., tensorflow, pytorch, jax, sklearn) before creating the variation.

kaggle models variations create ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new model variation under an existing model on Kaggle.

Usage:

kaggle models variations create -p <FOLDER_PATH> [options]

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the model variation files and the model-instance-metadata.json file (defaults to the current directory).
* -q, --quiet: Suppress verbose output.
* -r, --dir-mode <MODE>: How to handle directories within the upload: skip (ignore), zip (compressed upload), tar (uncompressed upload) (default: skip).
* --ignore-patterns <PATTERNS>: Patterns of files/dirs to ignore. Can be specified multiple times.


Example:

Create a new model variation using the metadata and files in the tmp folder, quietly, skipping subdirectories. (Assumes model-instance-metadata.json in tmp has been properly edited):

Example: Edit model-instance-metadata.json first

sed -i 's/INSERT_OWNER_SLUG_HERE/your-username/' tmp/model-instance-metadata.json

sed -i 's/INSERT_EXISTING_MODEL_SLUG_HERE/parent-model-slug/' tmp/model-instance-metadata.json

sed -i 's/INSERT_INSTANCE_SLUG_HERE/my-variation-slug/' tmp/model-instance-metadata.json

sed -i 's/INSERT_FRAMEWORK_HERE/jax/' tmp/model-instance-metadata.json

echo "a,b,c,d" > tmp/data.csv # Example model file
kaggle models variations create -p tmp -q -r skip

Purpose:

This command uploads your local model files (e.g., weights, architecture definition) and the associated variation metadata to create a new variation under a specified parent model on Kaggle. This effectively creates the first version of this model variation.

kaggle models variations get ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads the model-instance-metadata.json file for an existing model variation.

Usage:

kaggle models variations get <MODEL_VARIATION> -p <FOLDER_PATH>

Arguments:

* <MODEL_VARIATION>: Model variation URL suffix in the format owner/model-slug/framework/variation-slug (e.g., $KAGGLE_DEVELOPER/test-model/jax/main).

Options:

* -p, --path <FOLDER_PATH>: Folder to download the model-instance-metadata.json file to.

Example:

Download the metadata for model variation $KAGGLE_DEVELOPER/test-model/jax/main into the tmp folder:

kaggle models variations get $KAGGLE_DEVELOPER/test-model/jax/main -p tmp

Purpose:

This command retrieves the metadata file for an existing model variation. This can be useful for inspection or as a basis for an update.

kaggle models variations files ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists files for the current version of a model variation.

Usage:

kaggle models variations files <MODEL_VARIATION> [options]

Arguments:

* <MODEL_VARIATION>: Model variation URL suffix (e.g., $KAGGLE_DEVELOPER/test-model/jax/main).

Options:

* -v, --csv: Print results in CSV format.
* --page-size <SIZE>: Number of items per page (default: 20).
* --page-token <TOKEN>: Page token for results paging.

Example:

List the first 5 files for the model variation $KAGGLE_DEVELOPER/test-model/jax/main in CSV format:

kaggle models variations files $KAGGLE_DEVELOPER/test-model/jax/main -v --page-size 5

Purpose:

Use this command to see the files associated with the latest version of a specific model variation.

kaggle models variations update ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Updates an existing model variation on Kaggle using a local model-instance-metadata.json file.

Usage:

kaggle models variations update -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the model-instance-metadata.json file with the updated information (defaults to the current directory). Note: This command only updates the metadata of the variation, not the files. To update files, create a new version.

Example:

Update the model variation whose details are in tmp/model-instance-metadata.json (ensure the slugs and owner in the JSON match an existing model variation):

kaggle models variations update -p tmp

Purpose:

Use this command to change the metadata of an existing model variation, such as its description or other fields defined in the model-instance-metadata.json file. This does not upload new files or create a new version.

kaggle models variations delete ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a model variation from Kaggle.

Usage:

kaggle models variations delete <MODEL_VARIATION> [options]

Arguments:

* <MODEL_VARIATION>: Model variation URL suffix in the format owner/model-slug/framework/variation-slug (e.g., $KAGGLE_DEVELOPER/test-model/jax/main).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

Delete the model variation $KAGGLE_DEVELOPER/test-model/jax/main and automatically confirm:

kaggle models variations delete $KAGGLE_DEVELOPER/test-model/jax/main -y

Purpose:

This command permanently removes one of your model variations (and all its versions) from Kaggle. Use with caution.

---

Model Variations Versions Copy Section

Model Variation Versions Commands

Commands for managing versions of a specific Kaggle Model Variation. Each version represents a snapshot of the model variation files at a point in time.

kaggle models variations versions create ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new version of an existing model variation.

Usage:

kaggle models variations versions create <MODEL_VARIATION> -p <FOLDER_PATH> [options]

Arguments:

* <MODEL_VARIATION>: The target model variation URL suffix for the new version (format: owner/model-slug/framework/variation-slug, e.g., $KAGGLE_DEVELOPER/test-model/jax/main).

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the files for this new version (defaults to the current directory).
* -n, --version-notes <NOTES>: Notes describing this version.
* -q, --quiet: Suppress verbose output.
* -r, --dir-mode <MODE>: How to handle directories within the upload: skip (ignore), zip (compressed upload), tar (uncompressed upload) (default: skip).
* --ignore-patterns <PATTERNS>: Patterns of files/dirs to ignore. Can be specified multiple times.


Example:

Create a new version for the model variation $KAGGLE_DEVELOPER/test-model/jax/main using files from the tmp folder, with version notes "Updated model files", quietly, and skipping subdirectories:

Ensure tmp folder contains the new files for the version, e.g., data_v2.csv

echo "e,f,g,h" > tmp/data_v2.csv
kaggle models variations versions create $KAGGLE_DEVELOPER/test-model/jax/main -p tmp -n "Updated model files" -q -r skip

Purpose:

This command uploads a new set of files to an existing model variation, creating a new, numbered version. This allows you to track changes and revert to previous versions of your model variation files.

kaggle models variations versions download ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads files for a specific version of a model variation.

Usage:

kaggle models variations versions download <MODEL_VARIATION_VERSION> [options]

Arguments:

* <MODEL_VARIATION_VERSION>: Model variation version URL suffix in the format owner/model-slug/framework/variation-slug/version-number (e.g., $KAGGLE_DEVELOPER/test-model/jax/main/1).

Options:

* -p, --path <PATH>: Folder to download files to (defaults to current directory).
* --untar: Untar the downloaded file if it's a .tar archive (deletes the .tar file afterwards).
* --unzip: Unzip the downloaded file if it's a .zip archive (deletes the .zip file afterwards).
* -f, --force: Force download, overwriting existing files.
* -q, --quiet: Suppress verbose output.

Example:

Download version 1 of the model variation $KAGGLE_DEVELOPER/test-model/jax/main into the tmp folder, untar if applicable, force overwrite, and do it quietly:

kaggle models variations versions download $KAGGLE_DEVELOPER/test-model/jax/main/1 -p tmp -q -f --untar

Purpose:

This command allows you to retrieve the specific files associated with a particular version of a model variation.

kaggle models variations versions files ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists files for a specific version of a model variation.

Usage:

kaggle models variations versions files <MODEL_VARIATION_VERSION> [options]

Arguments:

* <MODEL_VARIATION_VERSION>: Model variation version URL suffix (e.g., google/gemma/pytorch/7b/2).

Options:

* -v, --csv: Print results in CSV format.
* --page-size <SIZE>: Number of items per page (default: 20).
* --page-token <TOKEN>: Page token for results paging.

Example:

List the first 3 files for version 2 of the model variation google/gemma/pytorch/7b in CSV format:

kaggle models variations versions files google/gemma/pytorch/7b/2 -v --page-size=3

Purpose:

Use this command to see the individual files that constitute a specific version of a model variation before downloading.

kaggle models variations versions delete ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a specific version of a model variation from Kaggle.

Usage:

kaggle models variations versions delete <MODEL_VARIATION_VERSION> [options]

Arguments:

* <MODEL_VARIATION_VERSION>: Model variation version URL suffix in the format owner/model-slug/framework/variation-slug/version-number (e.g., $KAGGLE_DEVELOPER/test-model/jax/main/1).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

Delete version 1 of the model variation $KAGGLE_DEVELOPER/test-model/jax/main and automatically confirm:

kaggle models variations versions delete $KAGGLE_DEVELOPER/test-model/jax/main/1 -y

Purpose:

This command permanently removes a specific version of your model variation from Kaggle. Use with caution. If it's the only version, this may lead to the deletion of the model variation itself if no other versions exist.

---

Models Copy Section

Models Commands

Commands for interacting with Kaggle Models.

kaggle models list ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists available models.

Usage:

kaggle models list [options]

Options:

* --owner <OWNER>: Filter by a specific user or organization.
* --sort-by <SORT_BY>: Sort results. Valid options: hotness, downloadCount, voteCount, notebookCount, createTime (default: hotness).
* -s, --search <SEARCH_TERM>: Search term.
* --page-size <SIZE>: Number of items per page (default: 20).
* --page-token <TOKEN>: Page token for results paging.
* -v, --csv: Print results in CSV format.

Examples:

1. List models owned by $KAGGLE_DEVELOPER (replace with your username), sorted by creation time, in CSV format:

kaggle models list --owner $KAGGLE_DEVELOPER --sort-by createTime -v

2. List the first 5 models matching the search term "gemini":

kaggle models list -s gemini --page-size 5

Purpose:

This command helps you find models on Kaggle, filtering by owner or searching by keywords, and sorting by various criteria.

kaggle models init ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Initializes a metadata file (model-metadata.json) for creating a new model. See metadata file format.

Usage:

kaggle models init -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: The path to the folder where the model-metadata.json file will be created (defaults to the current directory).

Example:

Initialize a model metadata file in a new temporary folder tmp:

mkdir tmp
kaggle models init -p tmp

Purpose:

This command creates a template model-metadata.json file. You must edit this file with your model's details, such as owner slug, title, model slug (URL-friendly version of the title), and a description, before creating the model on Kaggle.

kaggle models create ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Creates a new model on Kaggle.

Usage:

kaggle models create -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the model-metadata.json file (defaults to the current directory). This folder should also contain your model files that you intend to upload as part of the first model variation.

Example:

Create a new model using the metadata in tmp/model-metadata.json. (Assumes the metadata file has been edited with owner, title, and slug):

Example: Edit model-metadata.json first

sed -i 's/INSERT_OWNER_SLUG_HERE/your-username/' tmp/model-metadata.json

sed -i 's/INSERT_TITLE_HERE/My Awesome Model/' tmp/model-metadata.json

sed -i 's/INSERT_SLUG_HERE/my-awesome-model/' tmp/model-metadata.json
kaggle models create -p tmp

Purpose:

This command registers a new model on Kaggle using the provided metadata. After this, you will typically create model variations and versions.

kaggle models get ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Downloads the model-metadata.json file for an existing model.

Usage:

kaggle models get <MODEL> -p <FOLDER_PATH>

Arguments:

* <MODEL>: Model URL suffix in the format owner/model-slug (e.g., $KAGGLE_DEVELOPER/test-model).

Options:

* -p, --path <FOLDER_PATH>: Folder to download the model-metadata.json file to.

Example:

Download the metadata for model $KAGGLE_DEVELOPER/test-model into the tmp folder:

kaggle models get -p tmp $KAGGLE_DEVELOPER/test-model

Purpose:

This command retrieves the metadata file for an existing model, which can be useful for inspection or as a basis for an update.

kaggle models update ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Updates an existing model on Kaggle using a local model-metadata.json file.

Usage:

kaggle models update -p <FOLDER_PATH>

Options:

* -p, --path <FOLDER_PATH>: Path to the folder containing the model-metadata.json file with the updated information (defaults to the current directory).

Example:

Update the model whose details are in tmp/model-metadata.json (ensure the slug and owner in the JSON match an existing model):

kaggle models update -p tmp

Purpose:

Use this command to change the metadata of an existing model, such as its title, description, or other fields defined in the model-metadata.json file.

kaggle models delete ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Deletes a model from Kaggle.

Usage:

kaggle models delete <MODEL> [options]

Arguments:

* <MODEL>: Model URL suffix in the format owner/model-slug (e.g., $KAGGLE_DEVELOPER/test-model).

Options:

* -y, --yes: Automatically confirm deletion without prompting.

Example:

Delete the model $KAGGLE_DEVELOPER/test-model and automatically confirm:

kaggle models delete $KAGGLE_DEVELOPER/test-model -y

Purpose:

This command permanently removes one of your models (and all its variations and versions) from Kaggle. Use with caution.

kaggle models topics list ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Lists discussion topics for a model.

Usage:

kaggle models topics list <MODEL> [options]

Arguments:

* <MODEL>: Model ref in format <owner>/<model-slug> (e.g., google/gemma).

Options:

* --sort-by <SORT_BY>: Sort order. Valid options: hot, top, new, recent, active, relevance.
* -s, --search <SEARCH_TERM>: Search query to filter topics.
* --page-size <PAGE_SIZE>: Number of items per page.
* --page-token <PAGE_TOKEN>: Page token for pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle models topics list google/gemma --sort-by hot

Purpose:

This command lets you browse discussion topics for a specific model.

kaggle models topics show ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Displays a model discussion topic with all comments in tree form.

Usage:

kaggle models topics show <TOPIC_REF> [options]

Arguments:

* <TOPIC_REF>: A topic reference, which can be:
* <model>/<topic-id> (e.g., google/gemma/12345 - note that this supports multi-slash model slugs)
* <model> <topic-id> (two separate arguments, where <topic-id> is passed as second argument)
* <topic-id> (bare numeric ID)

Options:

* --page-size <PAGE_SIZE>: Number of comments to show per page.
* --page-token <PAGE_TOKEN>: Page token for comment pagination.
* -v, --csv: Print results in CSV format.
* -q, --quiet: Suppress verbose output.

Example:

kaggle models topics show google/gemma/12345

Purpose:

This command displays a full discussion topic along with all of its comments rendered in an indented tree structure.

---

Models Metadata Copy Section

A full model is composed of 3 types of entities:

1. The model
2. The variations
3. The variation versions

Let's take the example of efficientnet to explain these entities.

A model like efficientnet contains multiple variations.

A variation is a specific variation of the model (e.g. B0, B1, ...) with a certain framework (e.g. TensorFlow2).

Model Copy Chapter

To create a model, a special model-metadata.json file must be specified.

Here's a basic example for model-metadata.json:


{
  "ownerSlug": "INSERT_OWNER_SLUG_HERE",
  "title": "INSERT_TITLE_HERE",
  "slug": "INSERT_SLUG_HERE",
  "subtitle": "",
  "isPrivate": true,
  "description": "Model Card Markdown, see below",
  "publishTime": "",
  "provenanceSources": ""
}

You can also use the API command kaggle models init -p /path/to/model to have the API create this file for you for a new model. If you wish to get the metadata for an existing model, you can use kaggle models get username/model-slug.

Contents Copy Section

We currently support the following metadata fields for models.

* ownerSlug: the slug of the user or organization
* title: the model's title
* slug: the model's slug (unique per owner)
* licenseName: the name of the license (see the list below)
* subtitle: the model's subtitle
* isPrivate: whether or not the model should be private (only visible by the owners). If not specified, will be true
* description: the model's card in markdown syntax (see the template below)
* publishTime: the original publishing time of the model
* provenanceSources: the provenance of the model

Model Variation Copy Chapter

To create a model variation, a special model-instance-metadata.json file must be specified.

Here's a basic example for model-instance-metadata.json:


{
  "ownerSlug": "INSERT_OWNER_SLUG_HERE",
  "modelSlug": "INSERT_EXISTING_MODEL_SLUG_HERE",
  "instanceSlug": "INSERT_INSTANCE_SLUG_HERE",
  "framework": "INSERT_FRAMEWORK_HERE",
  "overview": "",
  "usage": "Usage Markdown, see below",
  "licenseName": "Apache 2.0",
  "fineTunable": False,
  "trainingData": [],
  "modelInstanceType": "Unspecified",
  "baseModelInstance": "",
  "externalBaseModelUrl": ""
}

You can also use the API command kaggle models variations init -p /path/to/model-variation to have the API create this file for you for a new model variation.

Contents Copy Section

We currently support the following metadata fields for model variations.

* ownerSlug: the slug of the user or organization of the model
* modelSlug: the existing model's slug
* instanceSlug: the slug of the variation
* framework: the variation's framework (possible options: tensorFlow1,tensorFlow2,tfLite,tfJs,pyTorch,jax,coral, ...)
* overview: a short overview of the variation
* usage: the variation's usage in markdown syntax (see the template below)
* fineTunable: whether the variation is fine tunable
* trainingData: a list of training data in the form of strings, URLs, Kaggle Datasets, etc...
* modelInstanceType: whether the model variation is a base model, external variant, internal variant, or unspecified
* baseModelInstance: if this is an internal variant, the {owner-slug}/{model-slug}/{framework}/{variation-slug} of the base model variation
* externalBaseModelUrl: if this is an external variant, a URL to the base model

Licenses Copy Section

Here is a list of the available licenses for models:

- Apache 2.0
- Attribution 3.0 IGO (CC BY 3.0 IGO)
- Attribution 3.0 Unported (CC BY 3.0)
- Attribution 4.0 International (CC BY 4.0)
- Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)
- Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
- Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0)
- Attribution-NonCommercial-ShareAlike 3.0 IGO (CC BY-NC-SA 3.0 IGO)
- BSD-3-Clause
- CC BY-NC-SA 4.0
- CC BY-SA 3.0
- CC BY-SA 4.0
- CC0: Public Domain
- Community Data License Agreement - Permissive - Version 1.0
- Community Data License Agreement - Sharing - Version 1.0
- GNU Affero General Public License 3.0
- GNU Free Documentation License 1.3
- GNU Lesser General Public License 3.0
- GPL 2
- MIT
- ODC Attribution License (ODC-By)
- ODC Public Domain Dedication and Licence (PDDL)
- GPL 3

Usage Copy Section

The following template variables can be used in this markdown:

- ${VERSION_NUMBER} is replaced by the version number when rendered
- ${VARIATION_SLUG} is replaced by the variation slug when rendered
- ${FRAMEWORK} is replaced by the framework name
- ${PATH} is replaced by /kaggle/input/<model_slug>/<framework>/<variation_slug>/<version>.
- ${FILEPATH} is replaced by /kaggle/input/<model_slug>/<framework>/<variation_slug>/<version>/<filename>. This value is only defined if the databundle contain a single file
- ${URL} is replaced by the absolute URL of the model

---

Output Format Copy Section

Kaggle CLI Output Formatting Documentation

This documentation describes the output formatting options available in the Kaggle CLI.

Output Format Options Copy Chapter

The Kaggle CLI supports choosing the output format for various commands that list information.

--csv (or -v) (or -v)')" title="Copy section prompt for LLMs"> Copy Section

Historically, many commands supported a -v or --csv option to display output as comma-separated values (CSV) instead of a formatted table.

Example:


kaggle competitions list --csv

--format ')" title="Copy section prompt for LLMs"> Copy Section

We have introduced a new --format option to provide a unified way to specify the output format.
It accepts the following values:
* csv: Display output as comma-separated values.
* table: Display output as a formatted table (default).
* json: Display output as JSON.

Example:


kaggle competitions list --format csv
kaggle competitions list --format table
kaggle competitions list --format json

For most commands, the JSON output is a list of objects representing the rows, with keys corresponding to the column headers. For detailed commands like topics show, it returns a structured object:


{
  "topic": { ... },
  "comments": [ ... ]
}

Projections (Field Selection) Copy Section

The --format option supports optional gcloud-style field selection (projections) by appending a comma-separated list of fields in parentheses to the format name. This allows you to limit the output to only the specified fields and control their order.

Projections are supported for all formats (csv, table, json).

Example:


Only show 'ref' and 'reward' columns for competitions in a table

kaggle competitions list --format "table(ref,reward)"
Export only 'id' and 'publicScore' to JSON for team submissions

kaggle competitions team-submissions --format "json(id,publicScore)" <team_id>
Export only 'name' and 'size' to CSV for dataset files

kaggle datasets files -d zillow/zecon --format "csv(name,size)"

You can specify fields using either their field names (e.g. totalBytes) or their display labels (e.g. size). If a field is not recognized, the CLI will display an error listing the allowed fields.

#### Special Case: Topics Show

For topics show commands, which output both a parent topic and a list of comments, the projection is applied to both types of objects. Fields matching the topic are applied to the topic output, and fields matching comments are applied to the comment output.

Example:


kaggle forums topics show 123 --format "json(title,content)"

{
  "topic": {
    "title": "Test Title"
  },
  "comments": [
    {
      "content": "Comment Content"
    }
  ]
}

The --csv (or -v) option and the --format option are mutually exclusive. You cannot specify both at the same time.

If you attempt to use both, the CLI will display an error:


kaggle competitions list --csv --format csv
Error: argument --format: not allowed with argument -v/--csv

Supported Commands Copy Chapter

The following commands support both --csv (legacy) and --format options:

Competitions Copy Section

Note: Ensure you have Python 3.11+ and the package manager pip installed.

Install the kaggle package with pip:

pip install kaggle

If you run into a Command kaggle not found error, ensure that your Python executable scripts are in your $PATH. For a local user install on Linux, the default location is ~/.local/bin. On Windows, the default location is $PYTHON_HOME/Scripts.

Authentication Copy Chapter

First, you will need a Kaggle account. You can sign up here.

After login, you can download your Kaggle API credentials at https://www.kaggle.com/settings/api by clicking on the "Generate New Token" button under the "API" section.

Option 1: OAuth Copy Section

Obtains access credentials for your Kaggle user accounts via a web-based authrorization flow.

kaggle auth login

Option 2: Environment variable Copy Section

export KAGGLE_API_TOKEN=xxxxxxxxxxxxxx # Copied from the settings UI

Option 3: API token file Copy Section

Store your Kaggle API token obtained from your Kaggle account API tokens settings page in a file at ~/.kaggle/access_token.

Option 4: Legacy API credentials file Copy Section

From your Kaggle account API tokens settings page, under "Legacy API Credentials", click on the "Create Legacy API Key" button to generate a kaggle.json file and store it at ~/.kaggle/kaggle.json.

CLI Usage Copy Chapter

Run the following command to list the available commands:

kaggle --help

The Kaggle CLI is organized into several command groups:

* Competitions: Manage and participate in Kaggle competitions.
* Datasets: Search, download, and manage Kaggle datasets.
* Forums: Browse and read Kaggle discussion forums.
* Kernels: Interact with Kaggle Kernels (notebooks and scripts). Includes information on using Kaggle Secrets.
* Models: Manage your Kaggle Models.
* Model Variations: Manage variations of your Kaggle Models.
* Model Variation Versions: Manage versions of your Kaggle Model Variations.
* Benchmarks: Define evaluation tasks, run them against LLM models, and download results.
* Configuration: Configure the Kaggle CLI.

Many commands produce output, which can be formatted for different purposes:

* Output Format: Control the format of output.

Tutorials Copy Chapter

Explore these tutorials to learn how to perform common tasks:

* Tutorials
* Create a Dataset
* Find and Download a Dataset
* Create a Model
* Create a Model Variation
* Create a Model Variation Version
* How to Submit to a Competition
* How to Submit to a Code Competition

---

Search Copy Section

Search Command

Search across all Kaggle content from a single command.

kaggle search ')" title="Copy chapter prompt for LLMs"> Copy Chapter

Runs a unified search over Kaggle competitions, datasets, notebooks, models,
users, and discussions and returns one ranked list of results. This is the
cross-content equivalent of the per-command -s/--search flags (such as
kaggle datasets list --search); use it when you don't yet know which content
type you're looking for, or when you want results from several types at once.

By default, kaggle search searches all CLI-supported content types
(competition, dataset, notebook, model, user, discussion, benchmark) — not every
backend document type (it excludes types the CLI cannot render usefully, such as
comments, blogs, and courses). Result ordering uses the backend's canonical
cross-content ranking. Use --type to narrow to specific types.

Usage:

kaggle search "<query>" [options]

Options:

* query: The term(s) to search for (required).
* -t, --type <TYPES>: Restrict results to a comma-separated list of content types. Valid types: competition, dataset, notebook, model, user, discussion, benchmark. If omitted, all of these CLI-supported types are searched.
* -m, --mine: Restrict the search to your own content.
* --sort-by <SORT_BY>: Sort order. One of: relevance (default), hotness, votes, dateCreated, dateUpdated, totalComments, lastViewed.
* --page-size <SIZE>: Number of results to show on a page (default: 20, max: 100).
* --page-token <TOKEN>: Page token for results paging (printed as Next Page Token = ... at the top of a page when more results exist).
* -v, --csv: Print results in CSV format instead of a table.
* --format <FORMAT>: Print results in the selected format (csv, table, json). Supports field projection, e.g. --format 'json(type,ref)'.

Result columns: type, ref, title, owner, votes. The ref column
is the identifier you can pass to other commands — owner/slug for datasets,
notebooks, and models; the bare slug for competitions and users.

Examples:

1. Search everything for a term:

kaggle search "protein folding"

2. Search only datasets and models:

kaggle search "diffusion" --type dataset,model

3. Find users:

kaggle search "andrew ng" --type user

4. Search your own content, most recently updated first:

kaggle search "baseline" --mine --sort-by dateUpdated

5. Get machine-readable output:

kaggle search "titanic" --format json

6. Fetch the next page:

kaggle search "llm" --page-size 50 --page-token <TOKEN>

---

Simulation Competitions Copy Section

Tutorial: Simulation Competitions

This tutorial walks you through interacting with a Kaggle simulation competition using the CLI — from finding the competition to downloading episode replays and agent logs.

Simulation competitions (e.g., Connect X, Lux AI) differ from standard competitions. Instead of submitting a CSV of predictions, you submit an agent (code) that plays against other agents in episodes. Each episode contains multiple agents competing against each other. You can identify simulation competitions on the competitions page by their "Simulation" tag, or by looking for competitions that mention agents, bots, or game environments in their description.

1. Find and Inspect the Competition Copy Chapter

Search for simulation competitions by keyword:

kaggle competitions list -s simulation

Once you've identified a competition (e.g., connectx), view its pages to read the rules, evaluation criteria, and other details:

kaggle competitions pages connectx

This lists the available pages (e.g., description, rules, evaluation, data-description). To read the full content of a page:

kaggle competitions pages connectx --content

You can also browse the competition's discussion forum to see what other participants are talking about — top strategies, common pitfalls, environment quirks. List the topics with:

kaggle competitions topics list connectx

This prints a table of topics with id, title, authorName, commentCount, votes, and postDate. Sort and paginate with -s/--sort-by (one of hot, top, new, recent, active, relevance) and --page-size:

kaggle competitions topics list connectx -s top --page-size 10

To read the full discussion under a topic, use the show subcommand:

kaggle competitions topics show connectx 12345

This returns the topic content and all its comments rendered in an indented tree structure.


2. Accept the Competition Rules  Copy Chapter
Before you can submit or download data, you must accept the competition rules on the Kaggle website. Navigate to the competition page (e.g., https://www.kaggle.com/competitions/connectx) and click "Join Competition" or "I Understand and Accept".
You can verify you've joined by checking your entered competitions: