DuckDB Online Shell: Run SQL in Your Browser, Zero Installation

Fri, 08 May 2026 00:00:00 +0000

Introduction

Picture this: you’re at a client site doing a live demo, and the laptop you’re using has zero data analysis tools installed. Or you’re at a coffee shop and need to quickly verify some data logic, but your machine only has 4GB of RAM. Or your collaborator is on a locked-down corporate computer without any installation privileges.

Traditional solutions fall short:

Ask IT to install software — come back in 3 days
Write a Python script on the spot — you’re 30 minutes in
Use Google Sheets — dataset is too large to upload

Enter DuckDB Online Shell (shell.duckdb.org).

Open a browser, visit this URL, and you have a full DuckDB v1.5.2 interactive query environment — all computation happens locally in your browser, and your data never leaves your machine.

This article is a comprehensive guide to what this tool can do, how to use it, and when it shines.

1. What Is shell.duckdb.org?

Core Technology: WebAssembly + DuckDB

The DuckDB Online Shell is powered by WebAssembly (Wasm). The DuckDB C++ engine is compiled to Wasm bytecode and runs directly in your browser. This means:

✅ No server required — all queries execute locally in your browser
✅ No installation — open a web page, zero configuration
✅ Data stays local — files you load never leave your computer
✅ Cross-platform — Windows, macOS, Linux, iPad, it all works
✅ Offline capable — once loaded, you can disconnect and keep working

Comparison with Traditional Approaches

Dimension	Online Shell	Local Install	Jupyter Notebook
Setup Steps	0	3-5	5-10
Time to First Query	2 seconds	5-30 minutes	2-5 minutes
Permissions Needed	None	Admin rights	Python env
Memory Limit	Browser cap	System RAM	System RAM
Shareability	One-click URL	Not shareable	Needs server

Technology Stack

┌─────────────────────────────────────┐
│ DuckDB Web Shell UI │
├─────────────────────────────────────┤
│ xterm.js (Terminal Emulator) │
├─────────────────────────────────────┤
│ DuckDB Wasm (WebAssembly Engine) │
├─────────────────────────────────────┤
│ Web API (File API, IndexedDB) │
├─────────────────────────────────────┤
│ Browser (Chrome/Firefox/Safari) │
└─────────────────────────────────────┘

2. Interface & Basic Operations

Page Layout

Open shell.duckdb.org and you’ll see:

Top navigation: New (reset session), Share (generate link), Import (upload files), Datasets (preloaded sample data)
Main area: A full terminal emulator with color output and syntax highlighting
Theme toggle: Light/dark mode support

Button	Function
New	Start a fresh session, resetting all state
Share	Generate a shareable URL for the current session
Import	Select files from your local computer to load
Datasets	Quickly load official example datasets

Available Datasets

The Datasets menu comes with 7 pre-configured datasets:

Dataset	Format	Description
NL Railway (DuckLake)	DuckLake	Dutch railway timetable data
Star Trek (CSV)	CSV	Star Trek episode cast information
Train Services (Parquet)	Parquet	Railway service data
TPCH on DuckLake	DuckLake	TPC-H benchmark data
NYC Taxi (Parquet)	Parquet	NYC taxi trip data (~15M rows)
NYC Bike Trips (Spatial)	Spatial	NYC bike sharing + geospatial data
Iceberg (S3 Tables)	Iceberg	Apache Iceberg tables on S3

Click any dataset and the Shell automatically loads it with example queries — one click to experience DuckDB’s power.

3. Core Commands

3.1 General Dot Commands

DuckDB Shell provides special dot-prefixed commands:

.help -- Show help for all available commands
.help -all -- Show extended help information
.version -- Display current DuckDB version
.tables -- List all registered tables
.schema [table] -- Show CREATE statement for a table
.timer on/off -- Enable/disable query timing
.maxrows 100 -- Set maximum display rows
.maxwidth 80 -- Set maximum display width
.mode markdown -- Switch output mode (markdown, csv, json, etc.)
.nullvalue 'N/A' -- Set NULL display text
.separator ',' -- Set column separator
.headers on/off -- Toggle column header display
.highlight on/off -- Toggle syntax highlighting

3.2 `.files` File Management Commands

This is one of the most useful command groups in the online shell. The .files commands manage files uploaded to your browser’s local memory:

.files list -- List all registered files
.files drop -- Remove a specific file
.files drop-all -- Clear all registered files

Note: There are two ways to upload files — click the Import button or use the .pick command.

3.3 Other Useful Commands

.pick -- Open file picker dialog from your computer
.print 'Hello' -- Print literal text to the terminal
.share -- Generate a shareable session URL
.show -- Display current configuration settings
.last -- Re-render the last result without truncation
.large_number_rendering MODE -- Toggle readable display of large numbers
.progress_bar on -- Enable progress bar display

4. Practical Examples

Example 1: Query a Remote Parquet File Directly

This is one of DuckDB’s most powerful features — run SQL directly on a URL without any download step:

-- Load the HTTPFS extension
LOAD httpfs;

-- Count rows in a remote Parquet file
SELECT COUNT(*) 
FROM 'https://blobs.duckdb.org/data/yellow_tripdata_2010-01.parquet';

Output:

┌──────────────┐
│ count_star() │
│ int64 │
├──────────────┤
│ 14863778 │
└──────────────┘

14.8 million rows, returned in seconds — all computed locally in your browser.

-- Multi-column aggregation
SELECT 
 COUNT(*) AS trips,
 AVG(tip_amount) AS avg_tip,
 AVG(trip_distance) AS avg_distance
FROM 'https://blobs.duckdb.org/data/yellow_tripdata_2010-01.parquet';

Output:

┌──────────┬────────────────────┬────────────────────┐
│ trips │ avg_tip │ avg_distance │
│ int64 │ double │ double │
├──────────┼────────────────────┼────────────────────┤
│ 14863778 │ 0.6714118288096592 │ 2.6282668161494915 │
└──────────┴────────────────────┴────────────────────┘

Example 2: Query a Local CSV File

Click Import (or run .pick), select a CSV file from your computer, then query it directly:

-- The filename (without extension) becomes the table name
-- If you uploaded "sales.csv":
SELECT * FROM sales LIMIT 10;

-- Aggregate by category
SELECT 
 category,
 SUM(amount) AS total_sales,
 COUNT(*) AS order_count,
 AVG(amount) AS avg_order_value
FROM sales
GROUP BY category
ORDER BY total_sales DESC;

Example 3: Query a Remote CSV File

LOAD httpfs;

SELECT * 
FROM 'https://blobs.duckdb.org/data/Star_Trek Season_1.csv'
LIMIT 5;

Example 4: Multi-Source JOIN

The online shell supports cross-file JOINs — load multiple files and run relational queries:

-- After importing orders.csv and customers.csv:
SELECT 
 c.name,
 c.city,
 SUM(o.amount) AS total_spent
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY c.name, c.city
ORDER BY total_spent DESC
LIMIT 10;

Example 5: Load DuckLake Format

DuckLake is DuckDB’s native data lake format:

-- Load the Dutch railway dataset
ATTACH 'https://blobs.duckdb.org/datalake/nl railway.ducklake' AS nl_railway (TYPE ducklake);
USE nl_railway;
.tables

-- Query train services
SELECT * FROM services LIMIT 5;

Example 6: Enable Timer for Performance Testing

.timer on

SELECT 
 passenger_count,
 COUNT(*) AS trip_count,
 AVG(total_amount) AS avg_fare
FROM 'https://blobs.duckdb.org/data/yellow_tripdata_2010-01.parquet'
GROUP BY passenger_count
ORDER BY passenger_count;

After enabling .timer, every query shows its execution duration at the bottom — great for benchmarking and optimization.

5. Typical Use Cases

Scenario 1: Analysis on a Borrowed Machine

Problem: You’re traveling and the borrowed laptop has no data tools installed.

Solution: Open a browser, visit shell.duckdb.org, upload data files or query remote Parquet URLs directly, and start analyzing immediately.

Real-world story:

A data analyst was at a client site needing to quickly analyze 50GB of server logs. The client’s laptop had nothing but a browser. He had the client place the Parquet files on S3, ran three SQL statements in the Online Shell, and had preliminary findings within five minutes.

Scenario 2: Client Demos

Problem: You need to demo data analysis capabilities to a client but don’t want to waste time configuring an environment.

Solution:

Place your data as Parquet/CSV on a publicly accessible URL
Use the Share feature to generate a link pre-loaded with your queries
The client clicks the link and sees the full analysis

Why this is powerful:

No software installation on the client’s machine
No version compatibility concerns
The client can try it themselves, building trust
Share links preserve the full query history

Scenario 3: Collaborators Without Install Permissions

Problem: Your collaborator works on a locked-down corporate computer and cannot install any software.

Solution: Share data via Import or a public URL. They can do all data exploration right in the browser.

Advantages:

No admin rights required
No IT approval process needed
Data and queries execute locally — secure and compliant
One-click session sharing with .share

Scenario 4: Teaching and Training

Problem: In an SQL training class, every student needs their own DuckDB environment.

Solution: All students open shell.duckdb.org in their browser — zero setup required.

Teaching advantages:

No environment configuration, start teaching in 5 minutes
Each student works independently
Students can use .share to show their work to the instructor
Built-in Datasets provide ready-made teaching data

Scenario 5: Rapid Prototyping

Problem: You want to quickly verify a SQL query logic without firing up your full development environment.

Solution: Open the Online Shell, write SQL, see results. Done in seconds.

-- Verify a date calculation:
SELECT 
 date '2026-05-08' + INTERVAL '1 month' AS next_month,
 date_trunc('month', date '2026-05-08') AS month_start,
 last_day(date '2026-05-08') AS month_end;

6. Limitations & Considerations

While incredibly useful, the Online Shell has some important limitations:

Memory Constraints

Browser Wasm memory is typically capped at 4GB (Chrome default)
For datasets over 2GB, consider sampling or filtering first
Large JOIN operations may exceed available memory

File Size Recommendations

CSV files: < 500MB
Parquet files: < 2GB (Parquet’s columnar compression means more data per MB)
Beyond this, use the native DuckDB installation

Network Dependency

First load requires a network connection to download the Wasm engine (~5MB)
Querying remote files via URL requires the internet
But once loaded, you can disconnect and continue working with imported data

Unsupported Features

Custom extensions cannot be installed (extensions must be compiled into Wasm)
Direct disk writes are not possible (browser sandbox restrictions)
.files add is not supported in the current version (use Import button or .pick)
Multithreaded parallelism is unavailable (Wasm single-thread limitation)

7. Comparison with Other Online Tools

Feature	DuckDB Shell	SQLite Online	Google Sheets	BigQuery Console
Execution Engine	Local browser	Local browser	Cloud server	Cloud server
Data Privacy	✅ Stays local	✅ Stays local	❌ Uploaded	❌ Uploaded
Offline Capable	✅ After load	✅	❌	❌
Max Data Size	~2GB	~100MB	~10M rows	Unlimited
Parquet Support	✅ Native	❌	❌	✅
SQL Dialect	Modern OLAP SQL	Traditional SQL	Limited SQL	Standard SQL
Learning Curve	Low	Low	Low	High
Cost	Free	Free	Free	Pay-per-use
Scalability	Browser-bound	Browser-bound	Good collab	Enterprise

8. Monetization Ideas

8.1 Knowledge Products Around the Shell

Product idea: Zero-Install SQL Bootcamp

Leverage the fact that the Shell requires no setup to teach SQL to non-technical audiences:

Course title: “Learn SQL in 3 Days — No Software Required”
Target audience: Operations, Marketing, Sales, HR — anyone non-technical
Selling point: No Python, no environment, just a browser
Pricing: $19-$99/person
Delivery: Pre-loaded Share links for each exercise

Delivery format:

Prepare 20 SQL exercises at different difficulty levels
Each exercise has a pre-loaded Share link
Students complete all exercises in their browser
Homework submitted via .share for instructor review

8.2 Corporate Training Services

Product idea: Data Literacy Workshops

Many companies want to upskill employees in data analysis but are blocked by IT security policies:

Problem: Employees only have browsers, no install permissions
Solution: DuckDB Shell-based data analysis workshops
Pricing: $500-$5,000/session (per day or half-day)
Selling point: Zero install, zero IT involvement, immediate productivity

8.3 Tech Blog with Interactive SQL

Use the Share feature to embed interactive SQL queries in blog posts:

End each article with a Share link — readers can reproduce your analysis with one click
Build an audience, then monetize through ads, paid newsletters, or consulting
Reference: “Interactive blog posts” regularly hit #1 on Hacker News and Reddit

8.4 Embedded Data Preview for SaaS Products

Integrate DuckDB Shell into your SaaS offering:

When users export data from your product, offer an “open in browser” feature
Users can analyze their exports immediately without leaving the browser
Position as a premium feature to increase conversion

8.5 YouTube/TikTok Video Content

Create a video series demonstrating the Shell’s instant-on capability:

Episode 1: DuckDB Shell in 60 seconds — analyze data with zero setup
Episode 2: 5 SQL tricks to replace Excel (browser edition)
Episode 3: Analyzing 14 million NYC taxi rows in a browser — live!
Episode 4: The ultimate demo hack: SQL analytics on any computer in 30 seconds

Video content is perfect for showing the Shell’s immediacy — it’s visually compelling and easy to share.

9. FAQ

Q: Does my data get uploaded to DuckDB servers?

No. All computation happens locally in your browser via WebAssembly. Data loaded into memory never leaves your computer.

Q: How large of a dataset can I handle?

Browser Wasm typically has a 4GB memory limit. Keep CSV files under 500MB and Parquet files under 2GB. For larger datasets, use the native DuckDB installation.

Q: Can I use it offline?

Yes. After the initial page load (which downloads the ~5MB Wasm engine), you can disconnect from the internet and continue working with data you’ve already imported.

Q: What file formats are supported?

All formats DuckDB supports: CSV, Parquet, JSON, Excel (with extension), and more. With the HTTPFS extension, you can also query remote files from S3 and GCS.

A Share link encodes your SQL query history. When the recipient opens the link, all queries are replayed, producing the same results (assuming the data source is accessible).

Q: How do I export query results?

Use .mode csv to switch to CSV output mode, then copy the terminal output. For bulk exports, use the local DuckDB installation.

10. Conclusion

DuckDB Online Shell is a “secret weapon” in the data analyst’s toolkit. No installation, no configuration, just a browser and a URL.

Its core value proposition:

Zero barrier to entry — anyone with a browser can use it
Data privacy — computation is local, data never leaves your machine
Full-featured — supports DuckDB’s core SQL syntax and file formats
Versatile — from ad-hoc queries to teaching, demos to collaboration

Next time you find yourself in any of these situations, don’t install software — try shell.duckdb.org:

Analyzing data on a borrowed machine
Doing a client demo without environment setup
Collaborating with someone on a locked-down computer
Quickly validating a SQL query

Visit shell.duckdb.org and start your analysis in three seconds.

This article is based on DuckDB Web Shell v1.5.2 (Variegata). DuckDB is an open-source embedded OLAP database; the Web Shell is a community WebAssembly port of the original project.

WebAssembly on DuckDB Lab