Skip to main content
Gateways are how you read from Tapedrive. Storage nodes serve only staked peers, so every ordinary read reaches the network through a gateway: a service that follows the chain the same way a node does, keeps the track metadata and object indexes locally, and serves decoded bytes over HTTP to anyone. The SDK targets gateways natively, and plain HTTP works when an SDK is impractical. There are tiers. Tapenet’s hosted public gateway serves browsers and light traffic: anonymous, free, and heavily rate-limited (rate limits). Sustained workloads use a paid gateway tier or run their own (gateway setup). If you’re coming from Solana, the shape is familiar: gateways play the role RPC providers play there. A free public tier exists, and serious applications pay a provider or run their own.

Staked, but not storing

On-chain, a gateway registers and stakes like a node but never joins the committee. It holds no spools, casts no votes, and owes no storage duties. The stake is what opens the door: storage nodes serve reads only to peers whose stake clears a network-voted threshold. So anyone who wants to serve reads has to stake first, and read capacity grows the same way everything else in the network does: participants showing up with stake (storage nodes, token economics).

What a gateway serves

In user terms: whole objects and tracks, range reads, and listings. Range reads follow the stream manifest, so a range over a huge file fetches only the segments it needs. Listings and metadata come from the gateway’s local object index without touching the chain. You always receive decoded bytes; slices are internal (the API reference).

How a read is assembled

On-chain state names the track’s group, and the group names the nodes. The gateway requests slices from them in parallel and reconstructs from the first sufficient set of valid responses. Over-requesting is cheap and cuts tail latency, and slow, missing, or dishonest nodes are not waited for. Every slice is verified against on-chain commitments before use, and the decoded result is verified before serving. Reconstruction happens stripe by stripe, so responses stream as they decode and per-connection memory stays bounded no matter how large the object is. Caching works on slices, not decoded objects. The slices that reconstruct a track add up to roughly the object’s size, so slice caching costs about what object caching would, while staying individually verifiable and reusable across range reads.
A gateway fanning a read across a spool group, one node slow and one absent, the response assembled from the first seven valid slices.

A read fans out across the group. The first seven valid slices win.

Writes

Gateways aren’t the write path. Writes are Solana transactions signed by you; the SDK and CLI talk to the chain and to storage nodes directly. The one exception is the S3-compatible gateway, which accepts HTTP writes and acts on-chain as a delegate on your tape (S3 gateway, delegation).

Running a gateway

Running a gateway follows the open protocol path: stake, follow the control plane, and serve. The gateway setup guide covers the prerequisites. A gateway’s local state is rebuilt entirely from the control plane (bootstrap by replay, then live block ingestion), so you can add, restart, or replace instances freely and scale horizontally behind a load balancer. A CDN or edge cache in front is an operator choice: it changes where content gets cached, and every proof still holds (serving through a CDN). Rate limits and access tiers are operator policy. The protocol itself doesn’t meter reads; gateways do, however their operators choose (gateway setup, rate limits). Gateways expose standard operational metrics (telemetry).