bigset

What if you had all the data in the world?

public

Forked

Build and maintain any dataset from the live web, that refreshes regularly

⚠️ BigSet is experimental. It works, sometimes surprisingly well, but expect rough edges. We’re building in the open and shipping fast. Things will break, improve, and change. Issues and feedback are very welcome.

What Is BigSet?

You type a sentence:

“YC companies that are currently hiring engineers, with their funding stage, location, and number of open roles.”

BigSet infers the schema automatically, sends autonomous agents to research it on the live web, verifies what they find against real sources, deduplicates, and hands you a structured dataset. Download as CSV or XLSX. Set a refresh cadence (30 min, 6 hours, 12 hours, daily, weekly) and the agents re-run on schedule, pulling fresh data so the dataset never goes stale.

Any topic. GPU prices. Competitor features. Research papers. Restaurant menus. Insurance quotes. Whatever you type, it builds. And keeps current.

You don’t pick a scraper, write selectors, or point it at a URL. You just describe the data you care about, set a refresh cadence, and BigSet handles the rest.

Built on TinyFish APIs.

✨ Why BigSet?

At the end of the day, every interaction with the web, whether it’s you or your AI agent, ultimately comes down to data. Prices, companies, jobs, research, availability, inventory. The web has all of it, scattered across millions of pages.

There are great tools out there for parts of this problem. Scraping frameworks that extract content from URLs you point them at. Search APIs that return ranked results. Pre-built actors for specific sites. Lead gen platforms that produce verified lists of people and companies. They work, and they work well for what they do.

But the moment you need something that cuts across those categories, or something none of them cover, you’re back to square one. Stitching together search, extraction, schema design, deduplication, verification, and a cron job to keep it fresh. For every dataset. Every time. The data is right there on the web. Getting it into a table you can use is still a project.

BigSet closes that gap. One sentence in, verified structured data out, refreshed on whatever cadence you set. Your agents get live data to reason over; you get a table you can actually use.

Any dataset. Any source. Always fresh. That’s the idea.

How It Works

You describe the dataset in plain English, as vague or specific as you like
AI infers the schema: column names, types, primary keys, where to look on the web
An orchestrator agent discovers entities via web search
Sub-agents fan out in parallel: each one investigates a single entity, fetches real data, and inserts a verified row
You get a structured table: browse it in the UI, export CSV or XLSX
Set a refresh cadence and the agents re-run on schedule, keeping the dataset current automatically

Things to Know Before You Start

It’s experimental. Expect rough edges; schema inference isn’t always perfect, and some topics work better than others.
Dataset generation takes 2-5 minutes. The agents are doing real web research: searching, fetching pages, verifying data. It’s not instant, but the output is real.
It works best for topics with publicly available web data. If the information exists on public web pages, BigSet can probably find it. Data behind logins or paywalls is out of reach for now.
Scheduled refresh keeps datasets current. Set a cadence (30 min to weekly) and the agents re-run automatically. No manual re-runs.
Datasets are downloadable, not queryable. You can browse in the UI and export CSV/XLSX. SQL query support is on the roadmap.

🚀 Quick Start

Prerequisites: Docker and Make

You’ll also need API keys from three services (all free to set up):

Service	What it’s for	Get your key
TinyFish	Web search + page fetching	tinyfish.ai/api-keys
OpenRouter	LLM calls (schema inference + agents)	openrouter.ai/settings/keys
Clerk	User authentication	dashboard.clerk.com

Step 1: Clone the repo

git clone https://github.com/tinyfish-io/bigset.git
cd bigset
cp .env.example .env

Step 2: Set up TinyFish (web access)

TinyFish powers all web search and page fetching. Search and Fetch have generous rate limits.

Go to tinyfish.ai and create an account
Go to API Keys and create a key
Paste it as TINYFISH_API_KEY in .env

Step 3: Set up OpenRouter (LLM)

OpenRouter routes LLM calls to Claude Sonnet (schema inference) and Qwen (agents). It’s pay-as-you-go; a dataset costs a few dollars in LLM usage.

Go to openrouter.ai and create an account
Go to Settings → Keys and create an API key
Paste it as OPENROUTER_API_KEY in .env
Add some credits; $5-10 is plenty to start

Step 4: Set up Clerk (auth)

Clerk handles user sign-in. The setup takes ~2 minutes:

Go to dashboard.clerk.com and create a new application
Pick a sign-in method (email, Google, GitHub, whatever you prefer)
Once created, go to Configure → API Keys in the sidebar
- Copy Publishable Key → paste as NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY in .env
- Copy Secret Key → paste as CLERK_SECRET_KEY in .env
Go to Configure → JWT Templates in the sidebar
- Click New template → select the Convex template → click Save
Go to Configure → Settings (or Domains)
- Find your Issuer URL (looks like https://your-app-name.clerk.accounts.dev)
- Paste it as CLERK_JWT_ISSUER_DOMAIN in .env

Step 5: Start everything

make dev

This installs dependencies, builds and starts all Docker services (Postgres, Convex, frontend, backend, Mastra), and deploys the Convex schema. On first run, it automatically generates the Convex admin key — no manual steps needed. See How make dev Works for the full breakdown.

Once everything is ready, you’ll see:

Service	URL
BigSet app	localhost:3500
Convex dashboard	localhost:6791
Mastra Studio (workflow inspector)	localhost:4111

Open localhost:3500 and click Get started to sign in.

Note: root .env is the only local env file. If you edit Convex functions in frontend/convex/, run make convex-push to deploy the changes.

Free tier: each signed-in account gets 2,500 row operations per calendar month (resets on the 1st, UTC). The header shows a live usage badge; system-owned curated datasets bypass the quota.

Step 6 (optional): Load curated datasets

BigSet includes 9 curated public datasets (AI companies hiring, GPU prices, model pricing, etc.) that show on the landing page:

make seed-public-datasets

This is idempotent; safe to run multiple times.

How `make dev` Works

make dev is designed to handle everything — first run, subsequent runs, and recovery from bad state. You should never need to run any other setup command. Here’s what it does, in order:

Validates your .env — checks that all required API keys are set (Clerk, OpenRouter, TinyFish). Stops with a clear error if anything is missing.
Installs dependencies — runs npm install in both frontend/ and backend/. Silent if already up to date.
Starts the database layer — brings up Postgres and Convex (self-hosted) first, since other services depend on them.
Waits for Convex — polls the Convex health endpoint until it’s ready (up to 120s).
Ensures the admin key — if CONVEX_SELF_HOSTED_ADMIN_KEY is empty in .env, generates one automatically and writes it. If a key exists, validates it against the running Convex instance. If the key is stale (e.g. you ran make clean and wiped the database), it detects the mismatch and regenerates.
Pushes Convex config — sets the Clerk JWT issuer URL in Convex so auth tokens are validated correctly.
Deploys Convex schema — pushes the table schema and functions from frontend/convex/ to the running instance.
Starts remaining services — brings up the frontend, backend, and Mastra. These read the now-populated .env including the admin key.
Streams logs — tails all container logs so you can see what’s happening. Ctrl+C to stop watching (containers keep running).

Commands

You only need three commands:

Command	What it does
`make dev`	Start everything (or recover from any broken state)
`make down`	Stop all containers (data is preserved)
`make clean`	Stop containers, delete all data, and clear the admin key

Other commands you might use during development:

Command	What it does
`make convex-push`	Deploy Convex schema changes (run after editing `frontend/convex/`)
`make seed-public-datasets`	Load 9 curated public datasets for the landing page

What if something goes wrong?

make dev is self-healing. If you hit a problem, the fix is almost always just running make dev again.

Problem	What happens
Missing `.env`	Error: “Run: cp .env.example .env”
Missing API key	Error tells you exactly which key to set
Stale admin key (after `make clean`)	Detected automatically, regenerated
Containers already running	No-op for running services, starts any that are missing
Convex won’t start	Error after 120s timeout — check Docker is running

If you want a completely fresh start: make clean then make dev.

Your `.env` at a Glance

Variable	Required	Where to get it
`TINYFISH_API_KEY`	✅	tinyfish.ai → API Keys
`OPENROUTER_API_KEY`	✅	openrouter.ai → Settings → Keys
`NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY`	✅	Clerk dashboard → API Keys
`CLERK_SECRET_KEY`	✅	Clerk dashboard → API Keys
`CLERK_JWT_ISSUER_DOMAIN`	✅	Clerk dashboard → Settings/Domains
`CONVEX_SELF_HOSTED_ADMIN_KEY`	Auto	Auto-generated by `make dev` on first run
`RESEND_API_KEY`	Optional	For “dataset ready” emails. Leave blank to skip.
`NEXT_PUBLIC_POSTHOG_KEY`	Optional	For product analytics. Leave blank to disable.

🛠 Tech Stack

Layer	Tech
Frontend	Next.js 16, React 19, Tailwind 4
Backend	Fastify, TypeScript (agent runner)
Auth	Clerk
Database	Convex (self-hosted)
Data Collection	TinyFish APIs (Search, Fetch, Browser)
AI orchestration	Mastra workflows + Vercel AI SDK + OpenRouter → Claude Sonnet (schema inference + populate agent)
Table view	TanStack Table + react-window virtualization
Exports	CSV (built-in) + XLSX (SheetJS, dynamic-imported)
Analytics	PostHog — events, session replay, error tracking (optional)

📁 Project Structure

bigset/
├── frontend/            Next.js 16 — UI + Convex schema & functions
│   ├── convex/          Convex functions, schema, authz + quota helpers
├── backend/             Fastify + Mastra — schema inference + populate agent
│   ├── src/pipeline/    Pure pipelines: schema inference + populate context
│   ├── src/mastra/      Mastra workflows, agents, and tools (Studio at :4111 in dev)
│   ├── src/email/       Transactional email (Resend) — sends "dataset ready" notifications
│   └── src/analytics/   Server-side PostHog wrapper for backend-only events
├── scripts/             One-off scripts (e.g. verify-authz.sh)
├── .env                 Local env for frontend, backend, Convex CLI, and Docker (not committed)
├── docker-compose.dev.yml
└── Makefile

🛣️ Roadmap

We’re building BigSet in the open. Here’s what’s coming:

TinyFish Browser + Agent integration **TinyFish Browser + Agent integration** — For JS-heavy sites, SPAs, and pages that need interaction to reveal data.
Agent-native API **Agent-native API** — So your agents can create, query, and consume BigSet datasets programmatically. Build datasets on the fly, export them, feed them to your agents today. Next up: agents generate and query datasets directly.
SQL query layer **SQL query layer** — Query your datasets with SQL instead of just exporting.
Per-cell source provenance **Per-cell source provenance** — Click any cell to see exactly where the data came from.
Healer agents **Healer agents** — Automatically detect and fix broken or stale rows.
Incremental updates **Incremental updates** — Refresh only what changed instead of rebuilding the whole dataset.

🏗 Building in Public

BigSet is a work in progress. We’re building in the open because the best ideas come from the people who actually want to use the thing.

We’d love your feedback, ideas, or help building — come say hi:

🐦 Twitter: @Tiny_Fish for project updates
🗣 Twitter: @not_simantak for the unfiltered version
🐛 GitHub Issues: Report bugs or request features

🤝 Contributing

Contributions are very welcome — whether it’s code, feedback, or just telling us what datasets you’d want to build.

Fork the repo
Create a branch (git checkout -b my-feature)
Make your changes
Run bash scripts/verify-authz.sh to confirm the authorization layer still holds
Open a PR

If you’re not sure where to start, open an issue or come say hi.

📄 License

AGPL-3.0

Find me

v0.3.3[beta]