Why Based

How Based compares to Web3 and decentralized alternatives to Notion.

The Problem

Every Web3 team needs a workspace. Most end up using Notion or Google Docs — centralized SaaS tools that fundamentally conflict with the values of data ownership, permissionless access, and composability that Web3 teams build for.

The existing Web3-native alternatives each solve a piece of the puzzle but none solve the whole thing: you get token-gated docs or decentralized storage or task boards or markdown publishing — never a complete, bucket-native workspace where your data is your data, stored in your own S3 bucket as plain JSON files.

What Makes Based Different

Based is built on a fundamentally different architecture than every competitor listed below.

The bucket is the database

Your data isn't locked in a proprietary cloud. Entities (customers, invoices, tasks — anything) are JSON files in an S3 bucket. Any S3-compatible provider works: AWS, Storj, MinIO, DigitalOcean, or your own infrastructure.

Bring Your Own Bucket (BYOB)

Organizations can connect their own S3 bucket. Business entities live at the bucket root as first-class collections. Based app metadata lives under a .based/ prefix. You own the data, the storage, and the access.

Database Blocks are views, not containers

Unlike Notion where databases own their rows, Based's Database Blocks are views over entity collections in the bucket. The same customers/ collection can appear as a table on one page, a board on another, and a gallery on a third — all reading the same JSON files.

Real editor, real blocks

Full Tiptap block editor with callouts, toggles, inline databases, and nested pages. Not markdown-only, not a wiki, not just docs — a complete workspace with structured data views embedded directly in pages.

Org-scoped workspaces

Organizations contain bases. Bases contain pages, entities, projects, tasks, and units. Token gating and wallet login happen at the org and base level. One team, many workspaces, one bucket.

Self-hostable

Based runs on your own infrastructure. No vendor lock-in at the application layer or the data layer. Your bucket is the single source of truth — you can read it with any S3 client, script against it, or build custom tools on top.

The Landscape

We've evaluated every active Web3 and decentralized Notion alternative. Here's where each one stands and what Based does differently.

CharmVerse

DAO operations workspace with token-gated pages, databases, and roles

Strength: Closest Notion-like feature parity in Web3; Notion import; $DEV token pricing

Gap: Tied to its own SaaS — you don't own the storage. No BYOB, no self-hosting, no bucket-level data sovereignty.

Fileverse

E2E encrypted docs and spreadsheets with IPFS/Arweave storage and on-chain portal contracts

Strength: Strongest decentralization story — content-addressed storage, wallet-based permissioning, GPL-licensed

Gap: Primarily documents and spreadsheets. No database views, no entity model, no Tiptap-style block editor with inline databases. Storage is content-addressed blobs, not a queryable entity layer.

Anytype

Local-first, P2P, E2E encrypted knowledge OS with offline support

Strength: Most serious decentralized Notion alternative architecturally. $13.4M from Balderton. Open repos.

Gap: No Web3 primitives — no wallet login, no token gating, no on-chain anything. P2P sync is powerful but doesn't give you a permanent, queryable data layer. Not bucket-native.

HackMD

Real-time collaborative Markdown editor with Arweave publishing and SIWE login

Strength: Excellent for protocol specs, governance docs, and permanent publishing to Arweave

Gap: Markdown-only — no databases, no entity model, no structured data views. Web2 SaaS pricing model. You publish to Arweave but don't own the editing layer.

DeWork

Task/bounty boards with token gating, on-chain payouts via Safe, and contributor discovery

Strength: Best Web3-native execution layer for bounties and contributor coordination

Gap: Not a docs/database workspace at all. No pages, no rich editor, no entity model. Teams use DeWork alongside a doc tool, never instead of one.

ChainWiki

Documentation sites with IPFS storage, NFT-linked page history, and on-chain attestations

Strength: Verifiable provenance for every page version — "GitBook but Web3"

Gap: Wiki/docs sites only — no databases, no inline views, no workspace structure. Pages are documents, not a queryable data layer.

Feature Comparison

Capability	Based	CharmVerse	Fileverse	Anytype	Notion
Own your storage (BYOB)	✓	✕	~	local	✕
Entities as JSON files in bucket	✓	✕	✕	✕	✕
Database Block views	✓	✓	✕	✓	✓
Rich block editor	✓	✓	~	✓	✓
Wallet login	✓	✓	✓	✕	✕
Token gating	✓	✓	✓	✕	✕
Self-hostable	✓	~	~	✓	✕
Open source	✓	✓	~	✓	✕
Decentralized storage	s3	✕	ipfs	p2p	✕
Org hierarchy	✓	✓	✕	✕	✓
API / scriptable data	✓	~	✕	✕	✓

Architecture: Based vs the Rest

┌───────────────────────────────────────────────────────────────┐
│  Centralized SaaS (Notion, CharmVerse)                        │
│                                                                │
│  Your data → Their database → Their API → You                  │
│  You get: convenience                                          │
│  You lose: ownership, portability, auditability                │
└───────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────┐
│  Content-addressed (Fileverse, ChainWiki)                      │
│                                                                │
│  Your data → IPFS/Arweave blobs → Smart contract registry      │
│  You get: immutability, decentralization                       │
│  You lose: queryability, real-time collaboration, ergonomics   │
└───────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────┐
│  Local-first P2P (Anytype)                                     │
│                                                                │
│  Your data → Local device → P2P sync                           │
│  You get: privacy, offline, sovereignty                        │
│  You lose: server-side queries, shared infra, Web3 primitives  │
└───────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────┐
│  Based (bucket-native)                                         │
│                                                                │
│  Your data → Your S3 bucket → JSON files you own               │
│  Based reads and writes them with S3WORM                       │
│  You get: ownership + queryability + real-time + Web3 + API    │
│                                                                │
│  customers/cust_001.json   ← you can read this with any tool   │
│  invoices/inv_042.json     ← curl, boto3, worm cli, scripts   │
│  .based/pages/pg_abc.json  ← Based app data, also yours        │
└───────────────────────────────────────────────────────────────┘

Who Based Is For

Web3 teams who want wallet-first identity, token gating, and org management — but also need a real workspace with databases, not just token-gated docs.
DAOs that need structured operations (units, tasks, projects, entities) in a tool their contributors can actually use daily, not just vote in.
Data-sovereign organizations who refuse to put their business data in someone else's database. BYOB means your S3 bucket is the source of truth — always.
Developers who want to build on top of their workspace data. Every entity is a JSON file accessible via S3 API, CLI, or custom scripts. No proprietary export required.
Self-hosters who want to run the entire stack on their own infrastructure, with their own bucket, their own auth, and zero dependency on Based's servers.

Getting Started

Ready to try Based? Read the Getting Started guide or jump straight into the app.