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.

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.

You can even 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.

Built on TinyFish APIs.

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.

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

• 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.

Prerequisites: Node.js 22+ with npm. No Docker needed.

npm install --global @adamexu/bigset
bigset

That's it. The bigset command downloads the current local BigSet release, starts Convex, the backend, the frontend, and the local credential bridge, then prints the app URL. Open 127.0.0.1:3500 in your web browser to use it.

The first run caches release files under ~/.bigset; after that, starting BigSet is designed to take only a few seconds.

On first launch, BigSet sends you to setup. You'll connect two services:

Local API keys are stored in your OS keychain.

For a one-off run without installing globally:

npx @adamexu/bigset

Useful local options:

Use this path when you're changing BigSet itself. The supported development workflow is still make dev.

Prerequisites: Node.js 22+ with npm, Docker, and Make.

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

make dev

make dev creates a local .env if needed, 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. See How make dev Works for the full breakdown.

Once everything is ready, you'll see:

Open localhost:3500. The setup screen will ask for TinyFish and OpenRouter credentials and save them to your OS keychain for this workspace.

TinyFish powers web search and page fetching. OpenRouter routes LLM calls to the models BigSet uses for schema inference and agents.

1. Create a TinyFish key at agent.tinyfish.ai/api-keys
2. Create an OpenRouter key at openrouter.ai/settings/keys
3. Paste both into BigSet's setup screen

OpenRouter is pay-as-you-go; $5-10 is plenty to start.

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: cloud signed-in accounts get 2,500 row operations per calendar month (resets on the 1st, UTC). Local mode bypasses the cloud quota and uses your TinyFish/OpenRouter accounts directly.

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.

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:

1. Validates your .env — creates local keychain bridge settings automatically.
2. Installs dependencies — runs npm install in both frontend/ and backend/. Silent if already up to date.
3. Starts the local keychain bridge — runs a host-side helper so Docker services can read/write this workspace's OS keychain entries.
4. Starts the database layer — brings up Postgres and Convex (self-hosted) first, since other services depend on them.
5. Waits for Convex — polls the Convex health endpoint until it's ready (up to 120s).
6. 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.
7. Configures Convex auth — sets BIGSET_LOCAL_MODE=1 for the local app.
8. Deploys Convex schema — pushes the table schema and functions from frontend/convex/ to the running instance.
9. Starts remaining services — brings up the frontend, backend, and Mastra. These read the now-populated .env including the admin key.
10. Streams logs — tails all container logs so you can see what's happening. Ctrl+C to stop watching (containers keep running).

You only need three commands:

Other commands you might use during development:

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

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

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

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

• TinyFish Browser + Agent integration — For JS-heavy sites, SPAs, and pages that need interaction to reveal data.
• 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 — Query your datasets with SQL instead of just exporting.
• Per-cell source provenance — Click any cell to see exactly where the data came from.
• Healer agents — Automatically detect and fix broken or stale rows.
• Incremental updates — Refresh only what changed instead of rebuilding the whole dataset.

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

^ This awesome team is behind BigSet! We'd love to have you on board :)

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

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

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

AGPL-3.0