S3 on Solana: storing app data with Tapedrive logoS3 on Solana: storing app data with Tapedrive
Spool Labs' Tapedrive keeps the bookkeeping on Solana and the bytes on a network of staked storage nodes. You prepay for a tape (capacity times epochs), write with the tape CLI, Rust SDK, Git or any S3 client, and read over plain HTTP. Early devnet access is live; mainnet is not dated yet.
devrels.xyz/a/398Tapedrive is object storage from Spool Labs that uses Solana as its control plane. Solana records which nodes are in the network and which pieces of data each one holds. A network of staked storage nodes keeps the bytes. You talk to it the way you already talk to storage: a CLI, a Rust SDK, a Git remote, plain HTTP, or any S3 client through a gateway.
It's in early access. The public network, Tapenet, runs on Solana devnet, and the site lists mainnet as "soon". This piece covers how it works, the commands that work today, what it costs, and where it fits next to Arweave, Irys and Shadow Drive. Everything here comes from docs.tape.network, the spool-labs/tape repo and the tape.network site as of 19 November 2026.
How it works
The architecture overview splits the system in two. Solana programs hold the state that matters for correctness: tape reservations, track registration, certification, votes and rewards. Tapedrive nodes store and serve the data, so Solana isn't in the data path for anything large.
- Tape: a prepaid reservation of capacity for a number of epochs. In S3 terms it's a bucket. A tape holds up to 65,536 tracks, committed into one Merkle tree, so the chain stores one small commitment per tape.
- Track: one piece of raw data written to a tape. A named track is an object, with listings and metadata.
- Slices and spool groups: a large track is erasure coded into slices, and the slices are spread across one spool group of storage nodes.
- Gateways: the public face. They follow the chain, read slices from storage nodes as staked peers, and serve decoded data over HTTP.
Writes. Your client encodes the data and computes the commitments locally, registers the track on Solana, then sends slices to the assigned group. Each node checks its slice against the on-chain commitment. Once a quorum has signed (14 of 20 on Tapenet), the client records one aggregate signature on Solana. That certification is the network's proof of availability. A node that missed the write catches up later.
Reads. A gateway asks the group's nodes for slices in parallel and rebuilds the data from the first k valid ones (7 on Tapenet). It checks each slice against the on-chain commitments, so slow or dishonest nodes get routed around. Reads don't submit a transaction.
Proof of storage
The challenge mechanism runs all epoch inside every spool group. A rotating leader announces a challenge drawn from on-chain randomness. Every node must answer with a Merkle proof for one specific piece of one specific slice, and it broadcasts that proof to the whole group. The group signs the round's result. A node's score is the share of rounds it passed, and that score scales its reward. After each epoch, an on-chain random audit makes each node reproduce one earlier proof. Fail it and the node forfeits the epoch and gets slashed. Any member that finds data that doesn't match its commitment can also submit an invalidation proof. The homepage puts it as nodes testing each other "many times a minute".
Self-healing
The docs describe erasure coding, verification and "bandwidth-optimal repair". The homepage says that if a node drops out, "the network heals the missing pieces." Because reads only need k of n slices, losing a few nodes doesn't make data unreadable.
Retention, immutability and access
This is where the marketing and the docs need reading together. tape.network says you choose how long data is kept "up to 100 years", that once you make data immutable nobody can change it, and that you choose who can open a "hidden file" and can take that access back. What the docs describe today is narrower:
- Retention is whatever you prepay. A tape lasts a set number of epochs, and expiry deletes data. Extension is permissionless: any wallet can pay to extend any tape, so a DAO or service can keep data alive without the owner's key. The docs we read don't state a 100-year maximum.
- Immutability applies to tracks. A track-addressed URL can only ever serve one payload, which is why gateways send
Cache-Control: immutable. Objects are different. Writing the same name again creates a new track (last write wins), and the owner or delegate can delete. We didn't find a documented command that locks a tape against changes. - Access: the docs say plainly that data on Tapenet is public, so encrypt anything private before writing it. The Rust SDK's object API lists encrypt-on-write as an option. Revocation in the docs means write access:
tape revokeremoves a delegate, and S3 credentials issued by a gateway are revocable.
Treat hidden files, the lock and the 100-year option as announced features until the docs cover them.
Ingesting straight from Solana
Small writes skip the erasure-coded path. They travel inside the Solana transaction and are certified the moment it confirms. Inline tracks can also be recovered from the Solana ledger. The homepage claims 150 ms latency on small writes this way. That figure is Tapedrive's own, and so are its other benchmarks: 3.79 million reads and writes a second on one node (3.30 times RocksDB's 1.15 million) and 17.1 thousand 4 KiB objects stored a second (1.59 times RustFS). We haven't reproduced any of them, and the site doesn't publish a methodology next to them.
The interfaces
- CLI: one installer sets up the
tapeCLI, the storage node, the gateway, a Git remote helper and thetape-installrelease manager. It supports Apple Silicon macOS and x86-64 glibc Linux only. Intel macOS, ARM64 Linux, Windows and musl Linux aren't supported yet. - SDK: tape-sdk for Rust. TypeScript, Python, Go, Swift and Kotlin are "in the works". The docs pin
tape-sdk = "0.4"; crates.io shows 0.5.0 (published 11 October 2026). - S3 gateway: part of
tape-gateway, on its own listener. Buckets are tapes, objects are named tracks, and credentials are real SigV4 keys issued by the gateway operator. - Hosting:
tape deploypublishes a static build tohttps://<tape-address-base32>.tape.site/, with no server or DNS needed. - Git:
git clone tape://<address>andgit push tape main. Storage is append-only, so anything you push can't be unpushed. Don't push secrets. - Gateway HTTP API: fetch objects by track address, serve site paths, list tracks, and get Merkle proof material for a track.
Quickstart on Tapenet
These commands come from the wallet and funding and quickstart pages. You need a Solana wallet with devnet SOL for fees and TAPE for storage.
# install the toolchain (Apple Silicon macOS or x86-64 glibc Linux)
curl -fsSL https://tape.network/install.sh | sh
tape --version
# wallet: Tapenet uses Solana devnet for transactions
solana-keygen new --outfile ~/.config/solana/id.json # skip if you already have one
solana config set --url devnet --keypair ~/.config/solana/id.json
export TAPE_KEYPAIR="$HOME/.config/solana/id.json"
solana addressFund that address twice. Get devnet SOL from faucet.solana.com, and TAPE from the TAPE faucet (sign in with GitHub). Neither faucet needs your keypair. Then reserve a tape, write and read:
tape balance # pubkey, rpc, sol and tape lines
tape create --capacity 100m --duration 7d --dry-run # price it, spends nothing
tape create --capacity 100m --duration 1d # reserve; becomes your active tape
tape write photo.jpg # registers, distributes, certifies
tape read <track-address> --out photo.jpgtape sends transactions through https://devnet.tape.network and falls back to Solana's public devnet RPC. Set TAPE_RPC_URL or pass --url to use your own. tape extend adds epochs, and tape resize --add 10m adds capacity. Keep the tape's keypair (saved under ~/.tape/cassettes/). It is the tape, and the chain keeps no list of which tapes belong to which wallet.
Hosting a site is one more command:
tape deploy ./dist/index.html
# Deployed 4 files (4 uploaded, 0 unchanged)
# URL: https://<tape-label>.tape.site/The same flow in Rust
From the SDK quickstart. write_bytes picks the path by size and certifies the track before it returns.
use tape_sdk::Tapedrive;
let payer = read_keypair_file("~/.config/solana/id.json")?;
let client = Tapedrive::new(rpc, payer);
let tape = TapeKey::generate();
let cost = client.estimate_cost(capacity, epochs).await?;
client.reserve(&tape, capacity, epochs).await?;
let data = std::fs::read("photo.jpg")?;
let receipt = client.write_bytes(&tape, &data).await?;
let bytes = client.read_bytes(&receipt.manifest).await?;Read-only clients don't need a keypair: Tapedrive::new_gateway_read_only(rpc, GATEWAY_URL). Any track is also readable with a plain curl "$TAPE_GATEWAY/object/<track-address>".
Writing from a Solana program
The Solana quickstart is the most Solana-native part of the docs. A program writes to a tape by CPI into the Tapedrive program, using build_track_write_ix from tape-api and invoke_signed. The tape owner delegates writes to a PDA the program controls, once. Size limits decide the path:
- Up to about 825 bytes: one transaction, certified on confirm. This is the Quill example.
- Up to 10 KiB: a program collects the payload across several transactions into a buffer PDA, then writes it with one CPI. This is the Bundle example, which uses Solana's 10 KiB instruction-data cap.
- Larger: an erasure-coded write from the SDK, off chain.
The core of Quill's write instruction, abridged from the docs:
use tape_api::instruction::build_track_write_ix;
use tape_core::track::data::{BlobData, BlobInfo, TrackObjectInfo};
use tape_core::types::StorageUnits;
let ix = build_track_write_ix(
(*payer.key).into(),
(*writer.key).into(), // the ["quill", tape] PDA the owner delegated to
(*tape.key).into(),
BlobInfo {
object: Some(TrackObjectInfo {
name: name.to_vec(),
content_type,
logical_size: StorageUnits::from_bytes(payload.len() as u64),
}),
data: BlobData::Inline(payload.to_vec()),
},
)
.map_err(|_| QuillError::TrackWriteBuildFailed)?;
invoke_signed(
&ix,
&[payer.clone(), writer.clone(), tapedrive_system.clone(),
tape.clone(), slot_hashes.clone(), tapedrive_program.clone()],
&[&[QUILL_SEED, tape.key.as_ref(), &[bump]]],
)?;Build, deploy and run it with the commands from the docs, then read the object back with the CLI:
cd examples/quill/program
cargo build-sbf
cargo test
solana program deploy --program-id target/deploy/quill-keypair.json target/deploy/quill.so
cd ../client
export SOLANA_RPC=<rpc url>
export KEYPAIR_PATH=~/.config/solana/id.json
export QUILL_PROGRAM_ID=<your program id>
cargo run --release -- all
tape object ls --bucket <tape-address>
tape object get --bucket <tape-address> greetings/0001 -Tapenet's gateway then serves the object at https://gw.tape.network/site/<tape-address>/greetings/0001. One catch: the docs say these examples live in the examples directory of the tape repository, but the public spool-labs/tape main branch has no examples folder. For now, copy the full code from the docs page. The crates pinned there are tape-api, tape-core and tape-crypto 0.4.
The S3 gateway, rclone and DuckDB
The S3 gateway setup takes four steps per bucket. Reserve a tape, delegate it to the gateway's key, get a SigV4 credential from the gateway operator, and use the tape's lowercase label as the bucket name.
tape create --capacity 100m --duration 7d # prints "label:", the S3 bucket name
curl -s https://gw.example.com/v1/s3 # gateway returns its endpoint and delegate key
tape delegate <gateway-delegate-address> # undo any time with: tape revoke
tape info # prints the label againThe gateway writes to your tape as a delegate, so it never holds your key. Then point stock tools at it. The rclone remote from the rclone quickstart looks like this (the keys and endpoint are the docs' placeholders):
# ~/.config/rclone/rclone.conf
[tapedrive]
type = s3
provider = Other
access_key_id = <access key from the gateway operator>
secret_access_key = <secret key>
endpoint = https://s3.example.com
region = solanarclone lsd tapedrive:
rclone copy ./photos tapedrive:my-bucket/photos
rclone sync ./photos tapedrive:my-bucket/photos
rclone check --size-only ./photos tapedrive:my-bucket/photosDon't pass --checksum. ETags here are on-chain commitments, not MD5 hashes. rclone mkdir reports success but creates nothing, because buckets come from tape create. rclone returns once the gateway accepts the files, and the writes reach the chain about a minute later for a small folder. With DuckDB, create a secret and query Parquet in place:
CREATE SECRET (
TYPE s3,
KEY_ID '<access key>',
SECRET '<secret key>',
ENDPOINT 's3.example.com',
REGION 'solana'
-- add URL_STYLE 'path' if the gateway has no wildcard DNS
);
COPY (SELECT * FROM events) TO 's3://my-bucket/events.parquet';
SELECT count(*) FROM read_parquet('s3://my-bucket/events.parquet') WHERE event_type = 'upload';The compatibility page lists what works. That covers ListObjectsV2, Get, Head and Put, Range reads, real on-chain DeleteObject, and multipart uploads with a 5 MiB minimum part. Versioning and ACLs return 501, SigV2 is treated as unsigned, and x-amz-meta-* headers are ignored. Buckets can also expire, which no AWS tool will warn you about.
Important: when we queried Tapenet's public gateway on 19 November, https://gw.tape.network/v1/s3 returned "endpoint": null and "delegate": null. So there's no hosted S3 endpoint to point rclone or DuckDB at yet. For S3 today you need a gateway operator who has enabled it, or you run your own gateway. The CLI, SDK, Git and HTTP paths work against Tapenet now.
Devnet status and getting access
- Tapenet runs on Solana devnet with six-hour epochs. It's pre-mainnet and "may be reset", so don't keep anything on it you can't recreate. Mainnet endpoints and launch details aren't published.
- Endpoints: gateway
gw.tape.network, Tapedrive RPChttps://devnet.tape.network, explorer explorer.tape.network. The core program is8psYLbgTujeTi3KirtV5Rr7CJUwwDuvN9eXzjN7iJMyTand the devnet TAPE mint isF7fLbFSfaoWrsN5xRL4G8pzgFEh9j2zGRANWuc4M3Gm2. - Reserving capacity: the "Reserve capacity" link on tape.network leads to the wallet and funding guide above. There's no signup or allowlist for the CLI path, just devnet SOL, faucet TAPE and
tape create. For large datasets, the site has a "Talk to us" form and a booking link, and the README points devnet users to Discord. - Running locally (a private network on your own hardware, with tapesvm in place of Solana) isn't released. There's an early-access form on the local page.
- Running a node on Tapenet needs stake and roughly 4 TiB of disk, 16 GB of RAM and a 500 Mbps connection.
- The free hosted gateway meters content endpoints per IP and returns
429withRetry-After. Real workloads are expected to use a paid gateway tier or their own gateway.
Pricing and the TAPE token
Tapedrive publishes its token economics. You pay once, in TAPE, when you reserve a tape. SOL only covers Solana fees and account rent. The protocol charges nothing per read, and gateways price read service.
- Cost is the current storage price times capacity times epochs. The default price operators start from is 954 base units of TAPE per MiB per epoch, about 1 TAPE per TiB per epoch. The node committee sets the price by vote and re-aggregates it every epoch, so check
--dry-runrather than hard-coding it. - A small fraction of each payment is burned, and the rest streams to storage nodes epoch by epoch over the tape's life. A subsidy vault tops up rewards early on, and the top-up shrinks every epoch.
- Total supply is 7,000,000 TAPE with 9 decimals, minted in full to a treasury at initialization. The docs say there's "no on-chain allocation split" and nothing new is issued.
- On Tapenet, the docs estimate that reserving 100 MiB for a week and deploying a small static site costs about 0.003 TAPE and 0.006 SOL. One 5 TAPE faucet claim covers many of those.
That's devnet TAPE from a faucet. No mainnet token price, distribution or launch date has been published, so there's no real-money cost to quote yet. The docs' own sample outputs show a 1-hour epoch and 0.0161226 TAPE for 100 MiB over 7 days, which doesn't match the six-hour epoch on the network page. Price your own reservation with --dry-run.
How it compares
We covered Irys's Solana upload path in Irys: a data-first programmable datachain.
| Tapedrive | Arweave | Irys | Shadow Drive | |
|---|---|---|---|---|
| Retention model | Prepaid term (capacity times epochs). Anyone can extend; expiry deletes data. | Permanent. One upfront fee priced for 20 replicas for 200 years, paid into an endowment. | Permanent by default, plus 30-day and 1-year terms since the Cascade hard fork (3 Aug 2026). | Paid storage accounts on GenesysGo's network. |
| Pays in | TAPE (SPL token) plus SOL fees | AR | IRYS; uploads can be paid with SOL through @irys/upload-solana | SHDW (SPL token) |
| Relationship to Solana | Solana is the control plane. Programs can write by CPI. | Separate chain | Separate L1 datachain (IrysVM, EVM-compatible) | Solana-native storage accounts |
| Interfaces | CLI, Rust SDK, S3 gateway, Git, HTTP, static hosting | Arweave transactions and gateways | JS upload SDKs, gateway | JS SDK and CLI |
| Status | Pre-mainnet; Tapenet on devnet, may be reset | Mainnet | Mainnet | SDK repo last pushed July 2024 (v6.0.0) |
- Versus Arweave: Arweave sells permanence up front. Tapedrive sells a term and makes extending it permissionless. Arweave fits records that must outlive you. Tapedrive is aimed at working data like datasets, backups, artifacts, sites and agent memory, where S3 compatibility and paying for time used matter more. See Arweave's endowment docs.
- Versus Irys: Irys now has term storage too, but it's its own chain with contracts that read stored data. Tapedrive keeps Solana as the source of truth, so a Solana program can write a small object in the same transaction as its other logic. See Irys's Cascade announcement.
- Versus Shadow Drive: Shadow Drive was the Solana-native default for years. The GenesysGo/shadow-drive SDK repo was last pushed in July 2024, and recent issues report broken endpoints. If you depend on it, have a migration plan. Tapedrive is the newer Solana-native option, but it isn't on mainnet yet.
Caveats
- Pre-mainnet. Tapenet can be reset. Mainnet timing, endpoints and token distribution aren't published.
- Public by default. Tapenet data is readable by anyone with the address. Encrypt before writing. The Git helper doesn't encrypt private repos yet.
- Expiry deletes data. Watch the expiry epoch and extend in time, or arrange for someone else to.
- Lose the TapeKey, lose the tape. Nothing in your wallet tracks which tapes you own.
- Rust-only SDK and a CLI limited to Apple Silicon macOS and x86-64 glibc Linux. The docs pin 0.4 crates while crates.io is on 0.5.0.
- No hosted S3 endpoint on Tapenet yet, as of our 19 November check. S3 needs an operator who has enabled it, or your own gateway.
- Marketing ahead of docs: hidden files with revocable access, an immutability lock and 100-year retention appear on the homepage but not in the docs. All performance numbers are Tapedrive's own claims.
- Repo hygiene: the public repo has no LICENSE file, and the examples the docs reference aren't in it. The latest release is v0.5.5 (14 October 2026). The earlier proof-of-work version lives on the
powbranch.
Links
Keep reading
Airwallex open-sourced Auticuro — a Rust wallet service using Raft consensus, CQRS, and event sourcing that hits P99 < 20ms at 10K TPS on a 5-node cluster. Solana hits 65K+ TPS with 400ms finality on a permissionless network. Same class of problem, completely different trust assumptions. Here's the comparison.
An audit report is worthless if you can't confirm the deployed bytecode is what was audited. Solana verified builds fix that: a Docker-pinned toolchain produces a deterministic .so, its hash is compared to the on-chain program data, and the result is written to a PDA anyone can read. Solana Explorer shows a verified badge. Here's the full workflow.
A payment channel where assets stay on Solana mainnet but transactions are private, instant, and controlled by the operator. Not a separate chain, not a bridge — escrow locks SPL tokens, the channel processes thousands of transactions at ~100ms, and withdrawals burn back to mainnet. The reference architecture for tokenised deposits and institutional capital markets.
Get new articles in your inbox
Technical deep-dives on Solana tooling, infrastructure, and ecosystem. No noise.
