# Kaggle Dataset Discovery – License, Size & Version Changes (`maydit/kaggle-dataset-discovery-monitor`) Actor

Find public Kaggle datasets by topic, declared license, size and activity. Track version and license changes in a bounded shortlist; export provenance-rich metadata without downloading files.

- **URL**: https://apify.com/maydit/kaggle-dataset-discovery-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 saved observations

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![Kaggle Dataset Discovery — illustrative workflow](https://mayd-it.com/assets/actor-banners/kaggle-dataset-discovery-monitor-2c6988ece3e6.png)

## Kaggle Dataset Discovery — License, Size & Version Changes

Build a reviewable shortlist before downloading a dataset. Search public Kaggle metadata, filter by declared license text and published size, and record versions and license changes for later review.

### Start in one minute

Paste this small input into Apify, run it, then open **Dataset** and **SUMMARY**. No Kaggle login or API key is required for these public metadata requests.

```json
{"query":"machine learning","sortBy":"votes","maxResults":3,"maxPages":1}
```

The default selects the first three matching entries from one source page. Export JSON to keep nested previous values, or CSV for flat review columns. Search rankings can change between runs.

### What you get

Each saved observation includes `datasetRef`, `title`, `licenseName`, `totalBytes`, `currentVersion`, `sourceUpdatedAt`, `downloadCount`, `voteCount`, `usabilityRating`, `sourceUrl` and `observedAt`. Missing source values remain `null`. Every row sets `licenseReviewRequired: true`.

**A declared license label is not permission to use a dataset commercially.** Review the original license, provenance and applicable restrictions before downloading or using the data. Popularity is not evidence of data quality, ownership or lawful reuse.

### Useful inputs

| Option | Use |
| --- | --- |
| `query` | A literal topic phrase, up to 120 characters. |
| `sortBy` | Source order: `votes`, `hottest`, `updated`, `active` or `published`. |
| `licenseIncludes` | Case-insensitive literal text within the source's declared license. Empty disables it. |
| `maxTotalBytes` | Exclude unknown or larger sizes; `0` disables the filter. |
| `minDownloads` | A minimum activity count, not a quality score. |
| `maxPages` | One to three bounded metadata pages. |
| `maxResults` | First matching records, up to 50. Default three. |
| `comparePrevious` | Save and compare observations within the same search scope. |
| `onlyChanges` | Emit only new or changed observations; implies history. |
| `snapshotName` | Separate named history; run each scope sequentially. |

For compact computer-vision candidates:

```json
{"query":"computer vision","sortBy":"votes","maxTotalBytes":10000000000,"maxResults":3,"maxPages":1}
```

For repeat license/version review:

```json
{"query":"credit card","sortBy":"votes","maxResults":3,"maxPages":1,"comparePrevious":true,"snapshotName":"credit-data-review"}
```

Run again with the same scope and `onlyChanges: true` to keep changed observations. `comparisonStatus`, `changedFields`, `previousObservedAt`, `versionChanged`, `licenseChanged` and `previous` explain the comparison. A dataset missing from a bounded search window is never called removed.

### Combine with other Actors

- [Hugging Face Dataset Discovery](https://apify.com/maydit/huggingface-dataset-discovery-monitor): compare a separately selected AI dataset catalog alongside these results. Set the Hugging Face Actor’s `queries` to an array containing this Actor’s `query`, keep source-specific identifiers, and manually review licenses. A Kaggle `datasetRef` is not a Hugging Face repository ID.
- [Website Content Change Monitor](https://apify.com/maydit/website-content-change-monitor): after reviewing a dataset, supply its public documentation URL as an item in that Actor's `startUrls`. Monitor only pages it can access; this tool does not download datasets or bypass logins.

### Coverage and failure behavior

This Actor reads the official public Kaggle listing API. It does not download files, read private datasets, train models, validate dataset contents or enumerate the complete catalog. `sourceUniverseComplete` is always false. `selectionComplete` describes only the requested bounded window. Empty matches are valid and distinct from a failed source.

Authentication challenges and rate limits stop work without bypass. A repeated page, malformed source record, exhausted time budget, source error or billing cap produces explicit incomplete coverage in `SUMMARY`. History advances only after a complete selected window and confirmed dataset saves. Concurrent writers are detected before committing; use distinct history names or sequential schedules.

### Pricing and automation

Prepared pricing is **$2 per 1,000 saved observations**, plus **$0.00005 per Actor Start event** at the base tier. Check the current Apify pricing tab before running. Errors and reports are not dataset rows. `maxResults` limits result volume; Apify's maximum run charge is a separate spending control.

Use a saved Apify Task with the same input for repeat checks, schedule it, and read `SUMMARY` before using the dataset downstream. Integrations and webhooks can route successful results into a review sheet or data catalog. Keep history tasks private and use separate history names for separate workflows.

### Support and source

For an issue, share the run ID, non-secret input and expected result through this Actor's Issues tab. Source reference: [official Kaggle API](https://github.com/Kaggle/kaggle-api). Mayd It LLC is an independent publisher and is not affiliated with Kaggle.

# Actor input Schema

## `query` (type: `string`):

Literal public dataset search phrase, 1–120 characters. No file downloads or private data.

## `sortBy` (type: `string`):

Source-provided sort order; a bounded changing search window, not a complete catalog.

## `licenseIncludes` (type: `string`):

Optional case-insensitive literal text filter. Matching a name does not establish commercial-use rights. Read the actual dataset license.

## `maxTotalBytes` (type: `integer`):

Bytes; zero disables this filter. Missing size is excluded when a size limit is requested.

## `minDownloads` (type: `integer`):

Activity signal only; not quality, revenue, uniqueness or licensing proof.

## `maxPages` (type: `integer`):

Up to three API pages (normally 20 metadata entries per page). No claim to enumerate all datasets. Stop earlier when the selected result count is reached.

## `maxResults` (type: `integer`):

Select the first matching datasets in source order, up to this many. This intentional top-N window is not a complete catalog.

## `comparePrevious` (type: `boolean`):

Opt in to publisher metadata history scoped by all search options and snapshotName. No removals are inferred from search-window absence.

## `onlyChanges` (type: `boolean`):

Implies comparePrevious; does not establish ownership, downloadability or rights.

## `snapshotName` (type: `string`):

1–80 letters, digits, underscores or hyphens. Run the same scope sequentially; avoid concurrent writers.

## `maxRunSeconds` (type: `integer`):

Hard request deadline. Source failures and partial work appear in SUMMARY; incomplete history is not committed.

## Actor input object example

```json
{
  "query": "machine learning",
  "sortBy": "votes",
  "licenseIncludes": "",
  "maxTotalBytes": 0,
  "minDownloads": 0,
  "maxPages": 1,
  "maxResults": 3,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "maxRunSeconds": 90
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `report` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "machine learning",
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/kaggle-dataset-discovery-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "machine learning",
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("maydit/kaggle-dataset-discovery-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "machine learning",
  "maxResults": 3
}' |
apify call maydit/kaggle-dataset-discovery-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/kaggle-dataset-discovery-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nGcrIvWyLsLKIp5sH/builds/bPmeNNLoB18FjB87x/openapi.json
