Observable

This Observable notebooks review covers what the platform is used for, its key features, Observable pricing, how notebooks compare with Observable Framework, where it shines and falls short, and which tools to compare it with. Observable was founded in 2016 by Mike Bostock, the creator of D3, and launched publicly in 2018. Today it is a family of products: web-based Observable Notebooks for exploring data with code, the open-source Observable Framework for building data apps and dashboards, Observable Canvases for collaborative analysis with SQL and AI, and open-source libraries such as Observable Plot and D3. According to Observable, more than 1,200,000 notebooks have been created and edited on the platform.

What is Observable used for?

Observable is used for data analysis and data visualization that goes beyond a standard chart builder. Notebooks combine narrative, code and live output in one document, which makes them a natural fit for exploratory analysis and data storytelling. Typical projects are exploratory analysis of a new dataset, interactive visualization for journalism and research, internal dashboards and reports, prototypes of a visualization before it goes into a product, and teaching data visualization with live examples.

Data scientists and analysts use notebooks to load data, query SQL databases, and try Observable Plot charts step by step. Developers and data teams use Observable Framework to turn that work into fast data apps and reports that live in Git. Product managers and business teams use Canvases to explore data together without writing code. The common thread is the web: everything runs in the browser, and every visualization can be shared as a link, embedded in another site, or published as a static site.

Key features

• Reactive notebooks: code blocks in Observable JavaScript, Markdown, HTML and SQL. When a value changes, every cell that depends on it updates, so inputs, filters and charts stay in sync without extra code.
• Observable Plot and D3: Observable Plot is a concise charting library for exploratory data visualization; D3 is the low-level library behind many custom interactive graphics. Both are open source and built by the Observable team.
• Data connections: SQL cells and a data table cell query databases and data warehouses from private notebooks, alongside file attachments, cloud files and web APIs. A self-hosted database proxy covers databases on a private network (Observable documentation).
• Collaboration: multiplayer editing, comments, forking, suggestions, version history, and public or private notebooks with access control.
• AI Assist: an AI assistant inside notebooks that drafts code and charts, added in 2023.
• Observable Framework: an open-source static site generator for data apps, dashboards and reports (see below).
• Observable Canvases: a collaborative data canvas launched in 2025, where teams explore data with point-and-click, SQL or AI and refine results into interactive visualizations (Observable Canvases).
• Notebooks 2.0: a technology preview with Notebook Kit, an open file format and command-line tool for building static sites from notebooks, and Observable Desktop, a notebook editor for macOS 15+ on Apple Silicon (Notebooks 2.0).

Observable pricing

The notebook plans on the Observable pricing page, as captured on 30 August 2026, are:

• Notebook Free: $0. Public and private notebooks, AI Assist, access to databases, cloud files and web API endpoints, version control, and community support through the forum.
• Notebook Pro: $22 per month per editor. Adds multiplayer code editing, scheduled notebook runs, workspace viewers, guest access at the notebook level, and removes the Observable watermark on notebook embeds.
• Viewers: $10 per month each on Pro, for people who only view and interact with notebooks.
• Enterprise: available on request; the workspace documentation describes custom SSO and audit logs.

Observable Framework, Notebook Kit, Observable Plot and D3 are free and open source under the ISC license. Canvases are not listed on the notebook pricing page; ask sales for the current price. Observable also asks about discounts for non-profits and educators on the same page.

The cost surprise to check is who counts as a seat. Pro is billed per editor, and viewers cost extra, so sharing private dashboards with a large audience adds up. Framework sites avoid seat costs when you host them yourself, because the output is plain static files.

Observable notebooks vs Observable Framework

Notebooks are for exploration: you open a new notebook in the browser, load data, and iterate on each Observable Plot visualization, with collaborators editing at the same time. Observable Framework is for delivery: you write Markdown files with reactive JavaScript, and Framework compiles them into a static site with instant page loads (Observable Framework).

The key idea in Framework is data loaders. A data loader is a script in any language, such as SQL, Python, R or Node.js, that runs at build time and writes a static snapshot of the data to a file. The dashboard then loads that file instead of querying the database on every visit. Because a project is just files in a folder, it fits normal software development: you can use your own editor, Git, unit tests and CI/CD, and host the result anywhere, or deploy to Observable. It ships with themes, grids and JS libraries including Observable Plot, D3, DuckDB, Vega-Lite, Mapbox GL JS, Leaflet and Mermaid. The latest release on GitHub is 1.13.4, from March 2026.

Notebook Kit brings the same file-based approach to notebooks. It stores a notebook in an open, human-readable format, so one notebook can be edited in the browser, in Observable Desktop, or in a code editor, and published as a static site.

Observable Plot and D3 for data visualization

Most charts on Observable are built with Observable Plot, the open-source visualization library the team released in 2021. Plot follows a layered grammar of graphics: you pass a dataset and a list of marks, such as dots, lines, bars or cells, and Observable Plot picks sensible scales, axes and legends, so the default chart already makes sense. A scatterplot or a faceted bar chart takes a few lines of code, and the Plot documentation has an example for every mark. For fully custom interactive graphics, D3 gives low-level control over the display of every element. Both work in vanilla JavaScript outside Observable too, so a chart prototyped in a notebook can move into a front end application without a rewrite. Built-in inputs, such as sliders, dropdowns, search boxes and tables, connect user controls to charts through reactive variables.

Observable notebooks vs Jupyter notebooks

Data scientists who know Jupyter notebooks will find the biggest difference in how cells run. In Jupyter, Python cells run in the order you execute them, which can leave stale state behind. In Observable, code runs in dependency order, like a spreadsheet, so a change updates everything that depends on it. Observable runs in the browser and uses JavaScript, while Jupyter runs Python on a server, which makes Jupyter the better fit for heavy computation and machine learning. Very large datasets can also hit browser performance limits in Observable; data loaders solve this by running Python or SQL queries at build time and sending only the result to the browser. Many teams use both: Python for analysis, Observable for sharing interactive results.

Getting started with Observable

Sign up for a free account and create a new notebook, or fork one of the public notebooks in the gallery and adapt it. Add a data file or connect a database, write a SQL cell or a JavaScript cell, and add a chart with Observable Plot in a few lines. Learn Observable JavaScript first: it is standard JavaScript with reactive cells, but the evaluation order follows dependencies rather than the order on the page. For a dashboard that needs to live in a codebase, run npx @observablehq/framework@latest create and follow the Framework getting started tutorial.

Where Observable shines — and where it falls short

Strengths:

• Best-in-class interactive graphics and custom visualization, from the team behind D3.
• Reactive notebooks make exploration fast and keep inputs and charts in sync.
• Framework, Plot and Notebook Kit are open source and produce static sites you can host anywhere.
• A large public gallery of notebooks to learn from and fork, with strong community support.

Trade-offs:

• JavaScript is the main language in notebooks; Python and R run only in data loaders at build time.
• Not a drag-and-drop business intelligence tool; building a chart still means writing some code.
• Private sharing on Pro is billed per editor, plus a fee per viewer, and free users get forum support only.
• Several products (notebooks, Notebooks 2.0, Framework, Canvases) with different workflows can be confusing at first.

How Observable compares

• Datawrapper: point-and-click charts and maps for publishing, no code.
• Power BI: Microsoft's business intelligence suite for dashboards on company data.
• Retool and Appsmith: internal tools with forms and tables rather than custom visualization.
• Dataiku: an end-to-end data science platform for teams working in Python and visual recipes.
• Mapbox and CARTO Builder: map-first platforms for location data.
• Google Sheets and Rows: spreadsheets with built-in charts for quick analysis.

Python-first notebooks such as Jupyter, Hex, Deepnote and Marimo are the closest alternatives for teams that work mainly in Python and SQL.

Is Observable worth it?

Observable is worth it if you need custom, interactive data visualization and are comfortable with some JavaScript. The free plan covers public and private notebooks with database access, and the open-source Framework is free for building fast dashboards you host yourself. It is less of a fit for teams that want a no-code BI tool, work only in Python, or need to share private dashboards with many viewers on a tight budget. If you want help building dashboards or data apps with Observable, the low-code agencies and developers on LowCodeDevs can take it on.

Sources

• Observable pricing: Notebook Free and Pro, viewer price (captured 30 August 2026).
• About Observable: founding, milestones and usage figures.
• Observable Framework documentation: static site generator, data loaders and libraries.
• Notebooks 2.0 Technology Preview: Notebook Kit and Observable Desktop.
• Observable Canvases: the collaborative data canvas.
• Connecting to databases: database clients and the self-hosted proxy.
• observablehq/framework on GitHub: ISC license and releases.
• Interesting ideas in Observable Framework, Simon Willison: data loaders and the move to open-source tooling.
• Observable Plot, data.europa.eu: the charting library in practice.
• Observable, datasciencenotebook.org: feature overview; its "no self-hosting" note applies to the hosted notebook platform, not to Framework or Notebook Kit sites.
• Observable alternatives, Livedocs: alternatives list (written by a competitor; its claim that Observable lacks SQL and Python support conflicts with Observable's SQL cells and Python data loaders).