# Walrus Docs

> Walrus is a decentralized blob storage protocol built on Sui. It provides robust, cost-effective
> storage for large binary objects with high availability guarantees using erasure coding. This
> documentation covers setup, usage, the client CLI, SDKs, on-chain integration, and Walrus Sites
> (decentralized web hosting).

> For the complete, unabridged page index see [llms-full.txt](https://docs.wal.app/llms-full.txt).

Important notes:

- Walrus stores data as **blobs** (immutable byte arrays). All blobs are public; use an encryption
service like Seal for private data.
- Walrus has two networks: **Mainnet** (production, uses real SUI/WAL tokens) and **Testnet** (for
development and testing).
- The `walrus` CLI is the primary client. It supports storing, reading, and managing blobs, and can
run as a local daemon exposing an HTTP API.
- **Walrus Sites** enable fully decentralized web hosting: static assets stored on Walrus, with a
Sui smart contract as the on-chain index.
- Costs involve WAL tokens (for storage) and SUI tokens (for on-chain transactions).

## Getting Started

- [Advanced Setup](https://docs.wal.app/docs/getting-started/advanced-setup.md):
    Advanced installation options for Walrus including building from source and binary
    installation. This page covers advanced setup options for Walrus, including building from
    source, installing from binaries, or using Cargo. For standard setup instructions, see Getting
    Started.
- [Getting Started](https://docs.wal.app/docs/getting-started.md):
    Walrus is a verifiable data platform for high-stakes systems like AI and onchain finance, where
    data is stored as blobs. Walrus uses an object storage architecture, where blobs are stored in
    a flat namespace rather than a hierarchy. There are no folders or directories.

## System Overview

- [Aggregators Publishers Relays](https://docs.wal.app/docs/system-overview/aggregators-publishers-relays.md):
    Walrus exposes three HTTP services. Callers send requests to the wrong one more often than they
    make any other endpoint mistake. An aggregator reads. A publisher and an upload relay both
    write, but they differ in who holds the wallet and who pays.
- [Available Networks](https://docs.wal.app/docs/system-overview/available-networks.md):
    Walrus Mainnet operates a production-quality storage network using corresponding resources on
    the Sui Mainnet. The Walrus Testnet operates in conjunction with the Sui Testnet and is used to
    test new features before they graduate to Mainnet.
- [Caching](https://docs.wal.app/docs/system-overview/caching.md):
    Walrus blobs are content-addressed and immutable, which makes them well suited to caching. A
    given blob ID always maps to the same bytes, so once a response is cached it never goes stale
    for that blob ID.
- [Core Concepts](https://docs.wal.app/docs/system-overview/core-concepts.md):
    Walrus stores data as blobs. Each blob is an immutable array of bytes. Any type of file, such
    as text, video, or source code, you can store on Walrus. All blobs uploaded to Walrus are
    publicly available. Sui is a blockchain that supports programmable transactions.
- [System Overview](https://docs.wal.app/docs/system-overview.md):
    Aggregators, Publishers, and Upload Relays: What each Walrus HTTP service does, which direction
    of traffic it handles, who pays for storage, and which endpoint to call, so you can tell an
    aggregator from a publisher from an upload relay.
- [Operations](https://docs.wal.app/docs/system-overview/operations.md):
    Blobs can be interacted with through familiar file system operations such as uploading,
    reading, downloading, and deleting. You buy storage on Walrus for a fixed number of epochs, so
    every blob has a lifetime.
- [Public Aggregators And Publishers](https://docs.wal.app/docs/system-overview/public-aggregators-and-publishers.md):
    An aggregator serves blob reads over HTTP, and a publisher accepts blob uploads over HTTP. Both
    roles run through the Walrus client's daemon mode: walrus aggregator for reads, walrus
    publisher for stores, or walrus daemon for both (see Operate an Aggregator and Operate a
    Publisher).
- [Quilt](https://docs.wal.app/docs/system-overview/quilt.md):
    Quilt is a batch storage feature designed to optimize the storage cost and efficiency of large
    numbers of small blobs. Before Quilt, storing small blobs (less than 10 MB) on Walrus involved
    higher per-byte costs due to internal system data overhead.
- [Red Stuff Details](https://docs.wal.app/docs/system-overview/red-stuff-details.md):
    This page continues from the RedStuff encoding algorithm overview with a concrete worked
    example. Consider a Walrus instance with $N = 7 = 3f + 1$ shards. This means the number of
    primary source symbols is $N - 2f = 3$, and secondary $N - f = 5$.
- [Red Stuff Parameters](https://docs.wal.app/docs/system-overview/red-stuff-parameters.md):
    RedStuff has specific properties, Walrus-specific parameters, and authentication mechanisms
    described in the RedStuff encoding algorithm. The following sections describe key design
    decisions, fault-tolerance properties, and storage overhead of the RedStuff encoding.
- [Red Stuff Recovery](https://docs.wal.app/docs/system-overview/red-stuff-recovery.md):
    This page continues from the RedStuff encoding example with a recovery scenario. Consider that
    shard 3 fails, losing its slivers, and needs to recover them. In the following, the symbols of
    the lost slivers are highlighted in red (the lower quadrant is never stored).
- [Red Stuff](https://docs.wal.app/docs/system-overview/red-stuff.md):
    The RedStuff encoding algorithm used in Walrus is an adaptation of the Twin-Code framework
    presented by Rashmi et al. [[1]](https://doi.org/10.1109/ISIT.2011.6033732).
- [Relay](https://docs.wal.app/docs/system-overview/relay.md):
    An upload relay is a server-side service that simplifies the upload process by handling the
    complexity of writing to multiple storage nodes. It provides batching capabilities and improved
    reliability for client applications.
- [Storage Costs](https://docs.wal.app/docs/system-overview/storage-costs.md):
    When choosing a platform to store and verify data, you should consider reliability, uptime,
    availability, programmability, and price predictability. Walrus offers a fixed, USD-denominated
    storage cost of $0.023/GB/month, allowing you to budget and scale with confidence. > Storing
    many small files?
- [Storage Pools](https://docs.wal.app/docs/system-overview/storage-pools.md):
    A storage pool is a single storage reservation that many blobs share. In the standard flow,
    every blob you store owns its own storage resource, bought for that blob's exact size and
    lifetime.
- [System Constraints](https://docs.wal.app/docs/system-overview/system-constraints.md):
    Storage limits, cost considerations, memory requirements, and other constraints to consider
    when building on Walrus. This page describes the practical limits and constraints you should
    consider when designing applications on Walrus. For current values, run walrus info.
- [View System Info](https://docs.wal.app/docs/system-overview/view-system-info.md):
    The Walrus system object contains metadata about available and used storage and the price of
    storage per KiB in FROST. These values are determined by 2/3 agreement between storage nodes
    for each storage epoch. You can pay to purchase storage space for specified durations.
- [Wal Tokenomics FAQ](https://docs.wal.app/docs/system-overview/wal-tokenomics-faq.md):
    This page answers common questions about the WAL token and how value flows through Walrus. It
    focuses on mechanics that are visible to users and integrators: what you pay, where those
    payments go, how staking and rewards work, and what actually happens when you burn a blob.

## Walrus Client

- [Walrus Client](https://docs.wal.app/docs/walrus-client.md):
    JSON Mode: Use JSON mode for programmatic access to all Walrus CLI commands with JSON-formatted
    input and output. Managing Blobs: Use the Walrus client to check, extend, delete, burn, share,
    and set attributes on blobs across their lifecycle.
- [JSON Mode](https://docs.wal.app/docs/walrus-client/json-mode.md):
    JSON mode exposes every Walrus client command and simplifies programmatic access to the CLI.
    You specify the command and all of its options as a single JSON string, and the CLI prints
    JSON-formatted results to stdout. Pass a single JSON object to walrus json.
- [Managing Blobs](https://docs.wal.app/docs/walrus-client/managing-blobs.md):
    Use the Walrus client to manage blobs and their metadata. Before you extend or depend on a
    blob, check that it is still stored and see when it expires. Use the blob ID: This reports
    whether the blob is stored and its availability period.
- [Network Health](https://docs.wal.app/docs/walrus-client/network-health.md):
    Intermittent upload failures usually mean storage nodes are unreachable, not that your client
    is misconfigured.
- [Quilts](https://docs.wal.app/docs/walrus-client/quilts.md):
    For efficiently storing large numbers of small blobs, Walrus provides the quilt feature. A
    quilt batches multiple blobs into a single storage unit, significantly reducing overhead and
    cost. Learn more about quilts. You can interact with quilts using a dedicated set of walrus
    subcommands.
- [Reading Blobs](https://docs.wal.app/docs/walrus-client/reading-blobs.md):
    The Walrus client lets you check a blob's storage status and certification, download its data,
    and control the consistency checks that protect reads.
- [Storing Blobs](https://docs.wal.app/docs/walrus-client/storing-blobs.md):
    All blobs stored in Walrus are public and discoverable by all. Do not store sensitive data on
    Walrus without additional protection. Store blobs on Walrus with the following command: After
    you upload a blob to Walrus, it has 2 identifiers: Blob ID: A way to reference the blob on
    Walrus.
- [Verifying Availability](https://docs.wal.app/docs/walrus-client/verifying-availability.md):
    When an agent stores data on Walrus, or receives a blob ID and plans to build on it, it needs
    to confirm the data is durably stored before depending on it.
- [Walrus CLI](https://docs.wal.app/docs/walrus-client/walrus-cli.md):
    Use the command-line interface (CLI) to interact with the Walrus client. The CLI is available
    by installing the walrus binary.

## HTTP API

- [Quilt HTTP APIs](https://docs.wal.app/docs/http-api/quilt-http-apis.md):
    Walrus supports storing and retrieving multiple blobs as a single unit called a quilt.
    Publishers and aggregators both support quilt operations. Set $PUBLISHER and $AGGREGATOR to
    endpoints from the Network Reference.
- [Reading Blobs](https://docs.wal.app/docs/http-api/reading-blobs.md):
    You can read blobs using HTTP GET requests with their blob ID or object ID. Set $AGGREGATOR to
    an aggregator endpoint from the Network Reference. > Reading a blob right after upload?
- [Storing Blobs](https://docs.wal.app/docs/http-api/storing-blobs.md):
    > No public Mainnet publisher > > Walrus has no public unauthenticated publisher on Mainnet.
    There are no plans to create one. On Mainnet, run your own authenticated publisher (or use the
    Upload Relay or TypeScript SDK directly).
- [Streaming Media](https://docs.wal.app/docs/http-api/streaming-media.md):
    You can play audio and video stored as Walrus blobs directly in a browser. Point an HTML media
    element, such as or , at a Walrus aggregator URL, and the browser streams the blob as it plays.
    No download step or plugin is required. Set $AGGREGATOR to an aggregator endpoint from the
    Network Reference.

## TypeScript SDK

- [SDKs](https://docs.wal.app/docs/typescript-sdk/sdks.md):
    Official SDKs from Mysten Labs, community-maintained SDKs, and community tools cover the main
    ways to build on Walrus: the TypeScript SDK for full client-side control, HTTP-based SDKs in
    other languages, and explorers for inspecting blobs and operators.

## Examples

- [Awesome Walrus](https://docs.wal.app/docs/examples/awesome-walrus.md):
    Walrus is a storage layer, and the products in this section show what teams build on top of it.
    Use them directly, or read their source as reference implementations for your own project.
    First-party products with Walrus as their storage layer.
- [Browser And Mobile](https://docs.wal.app/docs/examples/browser-and-mobile.md):
    Client apps that run in a browser or on a mobile device cannot open the many connections a
    direct store needs. A blob is split into slivers that go to every storage node, so an
    unprivileged client would have to manage dozens of parallel uploads and collect a confirmation
    from each node.
- [List all archived blobs recorded in the local database](https://docs.wal.app/docs/examples/checkpoint-data.md):
    The example application below is not the official Sui Archival service. The example uses that
    service as a checkpoint source and stores the archived data on Walrus, and it shows how to
    archive blockchain data in a reliable, deterministic, and resilient manner.
- [Examples](https://docs.wal.app/docs/examples.md):
    Example applications that demonstrate different workflows and use cases on Walrus Ecosystem:
    Projects and tools built on Walrus, including Walrus Memory for AI agents, first-party tooling,
    and the community-maintained Awesome Walrus directory.
- [Javascript](https://docs.wal.app/docs/examples/javascript.md):
    You can store and read Walrus blobs from JavaScript with plain HTTP calls: a publisher accepts
    uploads through PUT requests, and an aggregator serves downloads through GET requests. The
    built-in fetch API covers both.
- [Move](https://docs.wal.app/docs/examples/move.md):
    Every Walrus blob has a corresponding Blob object on Sui. In Move, the type of that object is
    Blob, defined in the walrus:blob module of the Walrus package.
- [Python](https://docs.wal.app/docs/examples/python.md):
    Walrus does not ship an official Python SDK. Python reaches Walrus through the interfaces that
    are language-agnostic instead: the HTTP API, the CLI, and Sui JSON-RPC.
- [Walrus Relay](https://docs.wal.app/docs/examples/walrus-relay.md):
    The Walrus upload relay lets browser apps store blobs without opening a connection to every
    storage node: the client sends a single request to the relay, and the relay encodes the blob,
    distributes the slivers to the storage node committee, and returns an availability certificate.

## Operator Guide

- [Operating Aggregator](https://docs.wal.app/docs/operator-guide/aggregators/operating-aggregator.md):
    Run a Walrus aggregator to expose the HTTP API.
- [Operator Guide](https://docs.wal.app/docs/operator-guide.md):
    Service providers on Walrus host network services such as storage nodes, aggregators, and
    publishers. Aggregator and Publisher Limitations: Request size limits, nginx caching
    configuration, and daemon metrics for Walrus aggregators and publishers.
- [Limitations](https://docs.wal.app/docs/operator-guide/limitations.md):
    By default, store blob requests are limited to 10 MiB. You can increase this limit through the
    --max-body-size option. Store quilt requests are limited to 100 MiB by default, and you can
    increase them using the --max-quilt-body-size option.
- [Auth Publisher](https://docs.wal.app/docs/operator-guide/publishers/auth-publisher.md):
    The authenticated publisher requires HTTP requests to store a blob to be authenticated. Use an
    authenticated publisher as a building block for services that need to store data over HTTP on
    Walrus Mainnet, where an open publisher is undesirable because of the SUI and WAL cost of
    publishing to Walrus.
- [Mainnet Production Guide](https://docs.wal.app/docs/operator-guide/publishers/mainnet-production-guide.md):
    Walrus does not provide a public unauthenticated publisher on Mainnet. There are no plans to
    create one because the publisher must pay SUI and WAL for every blob it stores. On Mainnet, a
    publisher should be privately operated for a specific application, service, or organization.
- [Operating Publisher](https://docs.wal.app/docs/operator-guide/publishers/operating-publisher.md):
    The publisher and daemon perform onchain actions and require a Sui wallet with sufficient SUI
    and WAL balances. To handle many parallel requests without object conflicts, they create
    internal sub-wallets (introduced in version 1.4.0) funded from the main wallet.
- [Signed Binaries](https://docs.wal.app/docs/operator-guide/signed-binaries.md):
    Walrus release binaries and Docker images are signed using Cosign with a GCP KMS key. Each
    binary has a corresponding .sig file containing its signature. Docker image signatures are
    stored in the registry.
- [Stake](https://docs.wal.app/docs/operator-guide/stake.md):
    In Walrus, anyone can delegate stake to storage nodes and, by doing so, influence which storage
    nodes get selected for the committee in future epochs and how many shards these nodes hold.
- [Backup Restore Guide](https://docs.wal.app/docs/operator-guide/storage-nodes/backup-restore-guide.md):
    Walrus storage nodes provide backup and restore functionality for the primary database
    containing blob data. This guide covers configuration requirements, operational procedures, and
    best practices for automated and manual backup processes and restore operations.
- [Commission Governance](https://docs.wal.app/docs/operator-guide/storage-nodes/commission-governance.md):
    You can change most node parameters using StorageNodeCap, and the storage node automatically
    updates them based on the values in the node configuration. However, authorization for contract
    upgrades and withdrawing the storage node commission is handled separately.
- [Storage Nodes](https://docs.wal.app/docs/operator-guide/storage-nodes.md):
    Overview of guides for setting up and operating a Walrus storage node. This section covers
    everything you need to set up and operate a Walrus storage node. Backup and Restore Guide: Back
    up and restore Walrus storage node databases with automated and manual procedures.
- [Slashing Walkthrough](https://docs.wal.app/docs/operator-guide/storage-nodes/slashing-walkthrough.md):
    A worked example of a slashing event on Mainnet, with the concrete vote, execute, and cleanup
    commands operators run end to end. This page walks through a hypothetical slashing event on
    Mainnet so you can see how the pieces fit together.
- [Slashing](https://docs.wal.app/docs/operator-guide/storage-nodes/slashing.md):
    Walrus protects the network from misbehaving storage nodes through an onchain slashing
    mechanism. Committee members vote against a candidate node, and when a quorum of voting weight
    is reached, anyone can finalize the slashing to burn the candidate's accumulated commission.
- [Storage Node FAQ](https://docs.wal.app/docs/operator-guide/storage-nodes/storage-node-faq.md):
    The storage node must have a wallet compatible with the Sui Rust SDK. This cannot be a hardware
    wallet or anything that requires user interaction for transactions, because the node needs to
    send transactions as part of normal operation. The walrus-node setup command creates such a
    wallet.
- [Storage Node Maintenance](https://docs.wal.app/docs/operator-guide/storage-nodes/storage-node-maintenance.md):
    Monitor, update, and maintain a Walrus storage node, including key metrics, update procedures,
    and community tools. This page covers the ongoing operation of your Walrus storage node after
    initial setup. Back up the /opt/walrus/config directory.
- [Storage Node Migration](https://docs.wal.app/docs/operator-guide/storage-nodes/storage-node-migration.md):
    Guide for migrating a Walrus storage node to new hardware with minimal downtime. This guide
    covers migrating a Walrus storage node to new hardware. It assumes you run the node (and
    optionally an aggregator and publisher) on the same host.
- [Storage Node Setup](https://docs.wal.app/docs/operator-guide/storage-nodes/storage-node-setup.md):
    Step-by-step guide for setting up a Walrus storage node, including system preparation, TLS,
    configuration, and registration. This page walks you through the full initial setup of a Walrus
    storage node, from system preparation to registration and first startup.
- [Upload Relay](https://docs.wal.app/docs/operator-guide/upload-relay.md):
    Walrus enables apps to store data from within end-user browsers that have low to moderate
    machine specifications (mobile devices, low-powered laptops, and so on).

## Sites

- [Github Actions Workflow](https://docs.wal.app/docs/sites/ci-cd/github-actions-workflow.md):
    Create a GitHub Actions workflow to automatically deploy your Walrus Site whenever you push to
    your repository. The workflow uses the official Deploy Walrus Site action maintained by Mysten
    Labs. [x] A GitHub repository containing your site's source files.
- [1. Reconstruct Sui client configuration from CI secrets.](https://docs.wal.app/docs/sites/ci-cd/other-ci-cd-platforms.md):
    The official Deploy Walrus Site action targets GitHub Actions only. On any other CI/CD
    platform, such as GitLab CI/CD, CircleCI, or Bitbucket Pipelines, you drive deployment directly
    through the site-builder CLI.
- [Preparing Deployment Credentials](https://docs.wal.app/docs/sites/ci-cd/preparing-deployment-credentials.md):
    To deploy a Walrus Site through a GitHub Actions workflow, the workflow must sign Sui
    transactions on your behalf. This requires 2 credentials: a private key stored as an encrypted
    GitHub secret, and the corresponding Sui address stored as a GitHub variable. [x] Install the
    Sui binary.
- [Adding Metadata](https://docs.wal.app/docs/sites/configuration/adding-metadata.md):
    The metadata section of ws-resources.json lets you add human-readable information to your
    Walrus Site object. This data is stored onchain and is used by portals, explorers, wallets, and
    other tools to display information about your site.
- [Site Configuration](https://docs.wal.app/docs/sites/configuration/site-configuration.md):
    In its base configuration, a Walrus Site serves static assets through a portal. However, many
    modern web applications require more advanced features, such as custom headers, client-side
    routing, and human-readable information.
- [Specifying HTTP Headers](https://docs.wal.app/docs/sites/configuration/specifying-http-headers.md):
    The headers section of ws-resources.json sets custom HTTP response headers for individual
    resources on your Walrus Site. Each key in the headers object is the exact path of a resource,
    always starting from the root /.
- [Bringing Your Own Domain](https://docs.wal.app/docs/sites/custom-domains/bringing-your-own-domain.md):
    By default, Walrus Sites are served through a portal at a subdomain address like
    https://example.wal.app. If you want to serve your site at a classic DNS domain you own, for
    example https://example.com, you can do so by deploying your own portal and configuring it to
    serve only your site.
- [DNS Configuration](https://docs.wal.app/docs/sites/custom-domains/dns-configuration.md):
    After setting up your portal and configuring it for your domain, you need to configure your
    domain's DNS to route traffic to the server running your portal. This guide covers adding DNS
    records, setting up HTTPS with a reverse proxy, verifying propagation, and troubleshooting
    common DNS issues.
- [Setting A SuiNS Name](https://docs.wal.app/docs/sites/custom-domains/setting-a-suins-name.md):
    Sui Name Service (SuiNS) provides human-readable names for Walrus Sites, similar to how DNS
    works for websites. Instead of sharing a long Base36 subdomain like , you can link a SuiNS name
    to your site's object ID and browse it at a readable address like my-project.wal.app.
- [Installing The Site Builder](https://docs.wal.app/docs/sites/getting-started/installing-the-site-builder.md):
    The site-builder is a CLI tool that lets you create, edit, and publish Walrus Sites. You can
    install it using suiup or a pre-built binary. [x] Install a recent version of Rust. [x] Install
    and configure Walrus. > Warning > > The stable branch of Walrus Sites is mainnet.
- [Publishing Your First Site](https://docs.wal.app/docs/sites/getting-started/publishing-your-first-site.md):
    The Walrus Sites site-builder uploads your website's files to Walrus, where resources like
    HTML, CSS, JavaScript, and images are stored as blobs. A Sui smart contract serves as an
    onchain index that maps each resource path to its Walrus blob ID and records site ownership.
- [Using The Site Builder](https://docs.wal.app/docs/sites/getting-started/using-the-site-builder.md):
    This reference page provides details on site-builder configuration and CLI commands.
- [Sites](https://docs.wal.app/docs/sites.md):
    Walrus Sites are decentralized websites built on Sui and Walrus. Your site's files are stored
    on Walrus, a decentralized storage network, while a Sui smart contract records ownership and
    maps each resource path to its content.
- [Components](https://docs.wal.app/docs/sites/introduction/components.md):
    A Walrus Site is made up of 4 main components that work together: the site's files stored on
    Walrus, a Sui object that indexes those files as resources, the site-builder CLI that publishes
    and updates the site, and a portal that serves the site to browsers.
- [Technical Overview](https://docs.wal.app/docs/sites/introduction/technical-overview.md):
    A Walrus Site is a static web site published entirely onchain, with no origin server. Sui
    stores the site's ownership and resource index, and Walrus stores the resource files
    themselves. A portal bridges these systems and serves the site to the browser over standard
    HTTP.
- [Known Restrictions](https://docs.wal.app/docs/sites/known-restrictions.md):
    You can use Walrus Sites to deploy almost any form of traditional static Web2 website built for
    modern browsers. There are, however, a number of restrictions that developers should keep in
    mind when creating or porting a website to Walrus Sites.
- [Avoiding Duplicate Content SEO](https://docs.wal.app/docs/sites/linking/avoiding-duplicate-content-seo.md):
    Duplicate content occurs when the same or substantially similar content is accessible at more
    than 1 URL. Search engines such as Google consolidate duplicate pages and assign ranking
    signals to whichever URL they consider canonical.
- [Linking From Walrus Sites](https://docs.wal.app/docs/sites/linking/linking-from-walrus-sites.md):
    Walrus Sites serves content stored on Walrus through a portal. All relative URLs in your site
    resolve against the onchain site object. Anything outside that object, such as third-party
    pages, APIs, CDN assets, other Walrus Sites, requires an absolute URL.
- [Linking To Walrus Sites](https://docs.wal.app/docs/sites/linking/linking-to-walrus-sites.md):
    A Walrus Site is addressed through a portal. The portal resolves the site from an onchain
    object and serves its content. To link to a Walrus Site from an external source, you construct
    a URL that the portal can resolve.
- [Redirects](https://docs.wal.app/docs/sites/linking/redirects.md):
    Walrus Sites supports 3 kinds of redirects: internal routing redirects, HTTP redirects, and
    object redirects. Internal routing redirects map URL paths within your site to specific
    resources. HTTP redirects return 3xx responses to send the client to a different URL.
- [Mainnet](https://docs.wal.app/docs/sites/portals/deploy-locally.md):
    To view a website deployed using Walrus Sites, you must use a Sites Portal. A portal retrieves
    site resources from Walrus and their corresponding Sui objects before serving the site in your
    browser. You can browse any Walrus Site deployed on Mainnet or Testnet using a Sites Portal.
- [Uncomment and configure when enableallowlist is true](https://docs.wal.app/docs/sites/portals/mainnet-testnet.md):
    Walrus Site Portals are used to access and browse a Walrus Site. The portal you run must match
    the network on which your site is deployed. Each network has its own onchain package, default
    RPC endpoint, and Walrus aggregator.
- [Production](https://docs.wal.app/docs/sites/production.md):
    A working deploy and a production site differ in a handful of predictable ways: which portal
    serves it, how client-side routes resolve, how caches behave across updates, and how new
    versions ship. Work through each section below before you share a production URL.
- [Access Control Options](https://docs.wal.app/docs/sites/security/access-control-options.md):
    Walrus stores every blob publicly by default. Anyone who knows a blob ID can fetch its contents
    directly from a Walrus aggregator, and Walrus does not enforce access control at the storage
    layer. Site metadata, including every resource path and blob ID, lives in public objects on
    Sui.
- [Site Data Authentication](https://docs.wal.app/docs/sites/security/site-data-authentication.md):
    Walrus Sites use SHA-256 hashes stored on Sui to verify that every resource served by a portal
    matches the content the site owner originally published.
- [Troubleshooting](https://docs.wal.app/docs/sites/troubleshooting.md):
    Solutions to common errors when deploying and browsing Walrus Sites. This page covers common
    errors when deploying and browsing Walrus Sites, organized by where they occur. Errors in this
    section relate to site-builder configuration.

## Troubleshooting

- [Error Handling](https://docs.wal.app/docs/troubleshooting/error-handling.md):
    Best practices for handling Walrus errors. This page covers how to handle Walrus errors
    programmatically in your applications. For a reference of specific error messages and their
    solutions, see Troubleshooting Common Errors. Not all errors are equal.
- [Grpc Migration](https://docs.wal.app/docs/troubleshooting/grpc-migration.md):
    Sui has deprecated JSON-RPC. Current Walrus clients already reach Sui over gRPC at the same
    full node URL your configuration lists, so migrating means upgrading your tooling rather than
    rewriting your configuration. For the Sui API surface itself, see the Sui API reference.
- [Troubleshooting](https://docs.wal.app/docs/troubleshooting.md):
    Resolve common issues with the Walrus CLI, configuration, and network connectivity. Before
    undertaking any other steps, make sure you have the latest walrus binary. If you have multiple
    versions in different locations, find the binary that is actually used with which walrus.
- [Network Errors](https://docs.wal.app/docs/troubleshooting/network-errors.md):
    Common errors in the Walrus CLI and network, with causes and solutions. Each entry below gives
    an error message you might hit when using Walrus, what causes it, and how to troubleshoot it.
    Errors in this section occur when the Walrus CLI cannot load or parse its configuration.
- [Reading Blobs After Upload](https://docs.wal.app/docs/troubleshooting/reading-blobs-after-upload.md):
    Walrus itself maintains strong consistency. Once the network certifies a blob, any aggregator
    reading directly from storage nodes returns it immediately. If your app reads blobs through a
    cached aggregator immediately after upload, plan for a short propagation window.

## Data Security

- [Data Security](https://docs.wal.app/docs/data-security.md):
    Walrus provides decentralized storage for application and user data. All data stored on Walrus
    is public and can be accessed by anyone. Walrus natively provides data availability and
    integrity guarantees. It does not provide confidentiality. > Caution > > Blob IDs are not
    secrets.

## Glossary

- [Glossary](https://docs.wal.app/docs/glossary.md):
    This glossary defines key terms used throughout the Walrus documentation, covering storage
    concepts, erasure coding, cryptographic primitives, token economics, and network roles. Storage
    node: Entity storing data for Walrus; holds one or several shards.

## Walrus Memory: Getting Started

- [Choose Your Path](https://docs.wal.app/walrus-memory/getting-started/choose-your-path.md):
    Walrus Memory supports several integration modes depending on how much control you need. Pick
    the one that fits your use case. > Tip > > These paths aren't mutually exclusive.
- [Quick Start](https://docs.wal.app/walrus-memory/getting-started/quick-start.md):
    The fastest way to get Walrus Memory running is through the TypeScript SDK.
- [What Is Walrus Memory](https://docs.wal.app/walrus-memory/getting-started/what-is-walrus-memory.md):
    Walrus Memory enables AI agents to operate reliably across apps and sessions, without losing
    context. Portable, verifiable, and fully controlled by you, it's the memory layer that lets
    agents handle complex workflows and coordinate using data they can trust.

## Walrus Memory: Fundamentals

- [Core Components](https://docs.wal.app/walrus-memory/fundamentals/architecture/core-components.md):
    Walrus Memory is made up of six core components that work together to give your agents
    portable, verifiable memory that they fully control. Source:
    fundamentals/architecture/core-components.md The TypeScript SDK is the main entry point for
    developers.
- [Data Flow Security Model](https://docs.wal.app/walrus-memory/fundamentals/architecture/data-flow-security-model.md):
    Walrus Memory's security model is split between onchain enforcement and offchain operations.
    Understanding where trust lives helps you make informed decisions about your deployment.
- [Funding Storage](https://docs.wal.app/walrus-memory/fundamentals/architecture/funding-storage.md):
    Walrus Memory writes your encrypted memories to Walrus as blobs, as described in How Storage
    Works. Someone has to pay for that storage. This page explains who, and the trade-offs between
    an agent holding WAL itself and having a third party sponsor the cost.
- [How Storage Works](https://docs.wal.app/walrus-memory/fundamentals/architecture/how-storage-works.md):
    When you call memwal.remember(...), the relayer accepts a background job immediately and then
    stores the memory asynchronously. Here's what happens.
- [Tracking Agent Storage](https://docs.wal.app/walrus-memory/fundamentals/architecture/tracking-agent-storage.md):
    Every memory an agent writes becomes a durable object on two systems: an encrypted blob on
    Walrus, and a Blob object on Sui that records who owns that blob and how long it lives. An
    agent that depends on its memory has to know which blobs it owns, when each one expires, and
    when to renew or drop it.
- [How Agent Memory Works](https://docs.wal.app/walrus-memory/fundamentals/concepts/how-agent-memory-works.md):
    AI agent memory is a durable, searchable store of what an agent has learned, kept outside the
    model so it survives across sessions, apps, and workflows.
- [Memory Space](https://docs.wal.app/walrus-memory/fundamentals/concepts/memory-space.md):
    A memory space is the isolated unit of storage in Walrus Memory. Think of it as a folder or
    bucket for your memories, you choose which memory space to store into and which to retrieve
    from. Each user can own as many memory spaces as they want.
- [Ownership And Access](https://docs.wal.app/walrus-memory/fundamentals/concepts/ownership-and-access.md):
    Walrus Memory puts you in full control of your memory. Programmable permissions and explicit
    ownership define how memory is shared, accessed, and updated, with delegate access for agents
    and workflows.
- [Verifiable Memory](https://docs.wal.app/walrus-memory/fundamentals/concepts/verifiable-memory.md):
    An AI agent is only as trustworthy as the memory it acts on. If memory can be silently altered,
    or if the service holding it can rewrite history or lock you out, the agent's decisions cannot
    be trusted.
- [Where To Store Agent Data](https://docs.wal.app/walrus-memory/fundamentals/concepts/where-to-store-agent-data.md):
    When you give an AI agent long-term memory, you have to decide where that data lives. The
    choice shapes what the agent can do later: whether its memory survives a restart, moves with
    the user to another app, stays under the user's control, and can be trusted. Most teams choose
    among four approaches.

## Walrus Memory: Mcp

- [Antigravity](https://docs.wal.app/walrus-memory/mcp/antigravity.md):
    Add Walrus Memory to Antigravity so the agent recalls context and saves durable facts. Install
    it as a plugin (adds automatic-memory hooks) or as MCP-only (just the tools). [x] Node.js 20+
    [x] A Walrus Memory account. The first memory tool call opens a browser sign-in (memwallogin).
- [Claude Code](https://docs.wal.app/walrus-memory/mcp/claude-code.md):
    Add Walrus Memory to Claude Code so it recalls context and saves durable facts as you work.
    Install it as a plugin (recommended; adds automatic-memory hooks) or as MCP-only (just the
    tools). [x] Install Node.js 20+ with npx on your PATH; check with node --version.
- [Claude Connector](https://docs.wal.app/walrus-memory/mcp/claude-connector.md):
    Claude's built-in custom connector flow adds Walrus Memory over OAuth 2.1. You approve access
    in the browser with your Sui wallet, and Claude never asks you for a delegate private key or a
    custom header. > Note > > The connector flow needs a relayer that has OAuth turned on.
- [Claude Desktop](https://docs.wal.app/walrus-memory/mcp/claude-desktop.md):
    Add Walrus Memory to Claude Desktop so the agent can save and recall durable facts. Claude
    Desktop uses the MCP server (the memory tools); the automatic-memory plugin hooks are available
    on Claude Code, Codex, Cursor, and Antigravity. [x] Node.js 20+ [x] A Walrus Memory account.
- [Codex](https://docs.wal.app/walrus-memory/mcp/codex.md):
    Add Walrus Memory to Codex so it recalls context and saves durable facts as you work. Install
    it as a plugin (recommended; adds automatic-memory hooks) or as MCP-only (just the tools).
- [Cursor](https://docs.wal.app/walrus-memory/mcp/cursor.md):
    Add Walrus Memory to Cursor so the agent recalls context and saves durable facts. Install it as
    a plugin (adds automatic-memory hooks) or as MCP-only (just the tools). [x] Node.js 20+ [x] A
    Walrus Memory account. The first memory tool call opens a browser sign-in (memwallogin).
- [Opencode](https://docs.wal.app/walrus-memory/mcp/opencode.md):
    Add Walrus Memory to OpenCode so the agent can save and recall durable facts. OpenCode uses the
    MCP server (the memory tools); the automatic-memory plugin hooks are available on Claude Code,
    Codex, Cursor, and Antigravity. [x] Node.js 20+ [x] A Walrus Memory account.
- [Overview](https://docs.wal.app/walrus-memory/mcp/overview.md):
    The Walrus Memory MCP server exposes your portable Walrus Memory as Model Context Protocol
    tools, so an AI agent can decide when to save and recall memories on its own.
- [Quickstart](https://docs.wal.app/walrus-memory/mcp/quickstart.md):
    Every supported client runs the same local server, and differs only in where the configuration
    lives. Pick your client below, add the server, restart, and sign in. [x] You need Node.js 20 or
    later, because the server runs through npx with no install step. [x] You need a Walrus Memory
    account.
- [Output example: GxK9pL2mQr8vN3jF5Ys7hT6wZ1cD4eR8](https://docs.wal.app/walrus-memory/mcp/reference.md):
    The Walrus Memory MCP package exposes the tools, flags, environment variables, and transport
    routes below. For per-client setup, start with the MCP overview.

## Walrus Memory: Relayer

- [API Reference](https://docs.wal.app/walrus-memory/relayer/api-reference.md):
    The Rust relayer exposes these routes. The route table lives in services/server/src/main.rs.
    See also: Environment Variables Configuration Versioning and Compatibility The routes below
    require signed headers, except the MCP transports, which use bearer authentication.
- [Benchmark CI Setup](https://docs.wal.app/walrus-memory/relayer/benchmark-ci-setup.md):
    This document records how to configure the relayer benchmark workflows. The live benchmark
    intentionally runs only the public relayer /api/recall path.
- [Nautilus Tee](https://docs.wal.app/walrus-memory/relayer/nautilus-tee.md):
    Run the Walrus Memory relayer with a TEE deployment pattern when you want the default SDK flow
    without giving the host operator direct access to plaintext memory payloads.
- [Observability](https://docs.wal.app/walrus-memory/relayer/observability.md):
    Production relayers should emit structured logs, scrape Prometheus metrics, and send alerts for
    the external systems Walrus Memory depends on: PostgreSQL, Redis, Sui RPC, OpenAI-compatible
    embedding/LLM APIs, Seal, Walrus, and the TypeScript sidecar. Every relayer request gets an
    x-request-id.
- [Overview](https://docs.wal.app/walrus-memory/relayer/overview.md):
    The relayer is the backend that turns SDK calls into memory operations. Using a delegate key
    signed by the client, it handles the critical workflows, embedding, encryption, storage, and
    search, on behalf of the user.
- [Public Relayer](https://docs.wal.app/walrus-memory/relayer/public-relayer.md):
    A managed relayer is a simpler experience for teams that want to get started without running
    infrastructure. If a managed relayer endpoint is available for your environment, it gives you
    the fastest path to integration.
- [All SUI coins for an address, largest first:](https://docs.wal.app/walrus-memory/relayer/runbook-gas-pool.md):
    When to use this: a gas-pool alert fires (the SUI gas pool maintenance alert), or relayer logs
    show wallet jobs aborting with or Enoki dryrunfailed plus 0x2:balance:split (ENotEnough, abort
    code 2).
- [Opt the write path into gRPC (testnet example)](https://docs.wal.app/walrus-memory/relayer/self-hosting.md):
    Self-hosting means running your own relayer, either pointing at an existing Walrus Memory
    package ID or deploying an entirely new Walrus Memory instance with your own contract,
    database, and server wallet. The managed relayer provided by Walrus Foundation is a reference
    implementation.
- [Synthetic Seal Cross Account](https://docs.wal.app/walrus-memory/relayer/synthetic-seal-cross-account.md):
    COMG-715 adds a production-safe negative synthetic on top of the Move unit test . The unit test
    covers the contract in isolation. This check would alert if a live identity from account A can
    authorize account B's Seal key. The script is read-only.
- [Versioning And Compatibility](https://docs.wal.app/walrus-memory/relayer/versioning-and-compatibility.md):
    The Walrus Memory relayer is the public protocol/API layer for SDKs, MCP clients, and
    self-hosted deployments. Treat every route, signed header, response field, runtime config
    field, and documented environment variable on this page as a versioned contract.

## Walrus Memory: Contract

- [Delegate Key Management](https://docs.wal.app/walrus-memory/contract/delegate-key-management.md):
    Delegate keys are lightweight Ed25519 keys used for SDK authentication. They are registered
    onchain in a MemWalAccount and verified by the relayer on every request.
- [Overview](https://docs.wal.app/walrus-memory/contract/overview.md):
    The smart contract (memwal:account) defines the onchain account model for Walrus Memory. It is
    a Move module deployed on Sui.
- [Ownership And Permissions](https://docs.wal.app/walrus-memory/contract/ownership-and-permissions.md):
    The owner is the Sui wallet address recorded by the MemWalAccount.

## Walrus Memory: Indexer

- [Database Sync](https://docs.wal.app/walrus-memory/indexer/database-sync.md):
    The indexer syncs account data into PostgreSQL so the relayer can resolve ownership quickly
    without hitting the blockchain on every request. Both the relayer and the indexer connect to
    the same PostgreSQL instance (with the pgvector extension enabled). Migrations run
    automatically on boot.
- [Onchain Events](https://docs.wal.app/walrus-memory/indexer/onchain-events.md):
    The indexer listens to Sui events emitted by the Walrus Memory contract and uses them to update
    local backend state.
- [Purpose](https://docs.wal.app/walrus-memory/indexer/purpose.md):
    The indexer keeps the backend in sync with onchain state so the relayer can resolve accounts
    quickly. Without the indexer, every authenticated request would require the relayer to scan the
    onchain AccountRegistry to find which MemWalAccount holds a given delegate key.

## Walrus Memory: Openclaw

- [How It Works](https://docs.wal.app/walrus-memory/openclaw/how-it-works.md):
    The plugin sits between OpenClaw's gateway and the Walrus Memory server. It operates through
    hooks, automatic callbacks that run on every conversation turn, and optional tools the LLM can
    call explicitly.
- [Overview](https://docs.wal.app/walrus-memory/openclaw/overview.md):
    The Walrus Memory plugin adds portable, verifiable agent memory to OpenClaw agents. It works
    alongside OpenClaw's existing file-based memory, automatically recalling relevant context and
    capturing new facts in the background, with no user action needed.
- [Quick Start](https://docs.wal.app/walrus-memory/openclaw/quick-start.md):
    Get the plugin running and test the memory loop in a few minutes. [x] OpenClaw installed and
    running You also need a delegate key, account ID, and relayer URL from Walrus Memory, the steps
    below guides you through getting these.
- [Reference](https://docs.wal.app/walrus-memory/openclaw/reference.md):
    Complete reference for every plugin capability. Hooks are the primary mechanism, they run
    automatically on every conversation turn without any configuration beyond enabling the plugin.

## Walrus Memory: Reference

- [Configuration](https://docs.wal.app/walrus-memory/reference/configuration.md):
    Use this page to pick the right config shape quickly. Used by: MemWal.create(config)
    withMemWal(model, options) | Field | Required | Notes | | --- | --- | --- | | key | yes |
    Delegate private key in hex | | accountId | yes | MemWalAccount object ID on Sui | | serverUrl
    | no | Relayer URL.
- [Console Identity Link](https://docs.wal.app/walrus-memory/reference/console-identity-link.md):
    Console (Walrus Console) and Walrus Memory (WM) are separate Enoki zkLogin applications.
- [Enoki Connect Requirements](https://docs.wal.app/walrus-memory/reference/enoki-connect-requirements.md):
    Enoki Connect lets an external application (a "connecting app," for example, Console)
    authenticate its users through Walrus Memory's Enoki-hosted identity flow. This requires
    configuration on two sides: WM's own Enoki app settings, and each connecting app's origin being
    allowlisted.
- [Environment Variables](https://docs.wal.app/walrus-memory/reference/environment-variables.md):
    This page lists the supported, public environment variables across Walrus Memory, grouped by
    where you set it: the client SDKs, the MCP server, the self-hosted relayer, and frontend apps.

## Walrus Memory: Architecture

- [Permanent Registry Design Intent](https://docs.wal.app/walrus-memory/architecture/permanent-registry-design.md):
    The AccountRegistry shared object in Walrus Memory is designed as a permanent append-only
    mapping of . Even if a user decides to deactivate or "delete" their account, their address
    remains in the registry.

## Walrus Memory: Security

- [Unsigned Health Check Rationale](https://docs.wal.app/walrus-memory/security/health-check-unsigned.md):
    GET /health and GET /version The health and version endpoints are intentionally left
    unauthenticated and unsigned. They do not require a valid Ed25519 signature in headers like the
    rest of the API.

## Walrus Memory: Examples

- [Chatbot](https://docs.wal.app/walrus-memory/examples/chatbot.md):
    The chatbot example (apps/chatbot) is a production-style AI chat app built on Next.js and the
    Vercel AI SDK. It shows the lightest-touch Walrus Memory integration: wrap the model once, and
    memory works for every conversation turn.
- [Example Apps](https://docs.wal.app/walrus-memory/examples/example-apps.md):
    The repo includes ready-to-run apps in apps/ that show different Walrus Memory integration
    patterns. Start here for app-level patterns; Quick Start and Walrus Memory Usage cover the
    basic SDK flow.
- [Noter](https://docs.wal.app/walrus-memory/examples/noter.md):
    The noter example (apps/noter) is a note-taking app with zkLogin sign-in, so users authenticate
    with OAuth instead of managing a wallet. It shows the note-to-memory pattern: free-form writing
    becomes structured facts that recall can find later.
- [Researcher](https://docs.wal.app/walrus-memory/examples/researcher.md):
    The researcher example (apps/researcher) is a research assistant that works in sprints. It
    shows long-form memory and session rehydration: each sprint's findings persist as a structured
    report, and a fresh session pulls back the relevant history before it starts.

## Walrus Oyster API

- [OpenAPI Specification (JSON)](https://docs.wal.app/oyster/openapi.json):
    Machine-readable OpenAPI 3.1 spec for the Walrus Oyster API. Use for client generation,
    testing, and agent integration.
- [API Reference](https://docs.wal.app/oyster/api-reference.md)
- [1. Create an app (server operator runs this once). app new auto-issues](https://docs.wal.app/oyster/getting-started.md):
    Follow these steps to complete your first interactions with Oyster. By the end, you have
    created a bucket, uploaded a blob, and downloaded it back.
- [Guides](https://docs.wal.app/oyster/guides.md):
    Practical guides for working with Oyster beyond the API reference.
- [Introduction](https://docs.wal.app/oyster/introduction.md):
    Oyster is a Web2-friendly object storage service backed by Walrus (decentralized blob storage)
    and Sui (onchain state). It gives you familiar HTTP and S3 APIs while your data is stored on a
    decentralized network. Every user has an account.
- [First page](https://docs.wal.app/oyster/json-api.md):
    The Oyster JSON API is served under /api/v1/. All requests and responses use JSON (except blob
    content, which is raw binary). Authenticated endpoints require a Bearer token in the
    Authorization header.
- [S3 API](https://docs.wal.app/oyster/s3-api.md):
    Oyster provides an S3-compatible API that works with the AWS CLI, boto3, the AWS SDK for
    JavaScript, and any other S3-compatible client. It uses standard AWS Signature Version 4
    (SigV4) authentication. The S3 API runs on the same HTTP port as the JSON API.

## Walrus Oyster API: Guides

- [From a file on disk](https://docs.wal.app/oyster/guides/aws-sdk.md):
    These examples show complete workflows using AWS SDKs with Oyster's S3-compatible API. For
    initial SDK setup, see S3 setup.
- [Blob Lifecycle](https://docs.wal.app/oyster/guides/blob-lifecycle.md):
    Blobs progress through a well-defined lifecycle from upload to expiration. Oyster's automatic
    extension service keeps your data alive. Walrus storage is epoch-scoped, not time-scoped.
- [Full replace — the blob ends up with exactly these two tags](https://docs.wal.app/oyster/guides/cli.md):
    oyster-cli is a command-line tool for interacting with Oyster. It wraps the JSON API and
    handles authentication, content-type detection, and pagination for you.
- [Upload the same file to two different keys](https://docs.wal.app/oyster/guides/content-addressing.md):
    Oyster uses content addressing to identify blobs. A blob's identity is derived from its
    contents, not from where it is stored. This enables deduplication, integrity verification, and
    content-based retrieval. When you upload data to Oyster, the server computes a BLAKE2s-256 hash
    of the raw bytes.
- [Key Rotation](https://docs.wal.app/oyster/guides/key-rotation.md):
    Every Oyster account's wallet is an Ed25519 key that Pearl derives from a master seed with
    HKDF-SHA256. Pearl can hold several seeds at once, each with a version number, and every
    account records which version its wallet derives from (accounts.keyversion).
- [Web Signup](https://docs.wal.app/oyster/guides/web-signup.md):
    Oyster can serve a self-serve signup page at /signup. A user signs in with Google, passes a
    Cloudflare Turnstile anti-bot check, and receives an app plus its first admin key, the same
    kind of key an operator would otherwise issue with oysterd app issue-admin-key.
- [Register or rotate. Each call generates a fresh Ed25519 keypair;](https://docs.wal.app/oyster/guides/webhooks.md):
    Oyster posts a single webhook event: account.fundingrequired. It tells the owning app that an
    account's Pearl-derived wallet cannot cover the next extendstoragepool PTB. Top up the wallet
    and the next extension cycle succeeds.

## 01 Announcing Walrus

- [01 Announcing Walrus](https://docs.wal.app/blog/01_announcing_walrus.md):
    Walrus is an innovative decentralized storage network for blockchain apps and autonomous
    agents. The Walrus storage system is being released today as a developer preview for Sui
    builders in order to gather feedback. We expect a broad rollout to other web3 communities very
    soon!

## 02 Devnet Update

- [02 Devnet Update](https://docs.wal.app/blog/02_devnet_update.md):
    We have redeployed the Walrus Devnet to incorporate various improvements to the Walrus storage
    nodes and clients. In this process, all blobs stored on Walrus were wiped. Note that this may
    happen again on Devnet and Testnet, but obviously not on the future Mainnet.

## 03 Whitepaper

- [03 Whitepaper](https://docs.wal.app/blog/03_whitepaper.md):
    In June, Mysten Labs announced Walrus, a new decentralized secure blob store design, and
    introduced a developer preview that currently stores over 12TiB of data. Breaking the Ice
    gathered over 200 developers to build apps leveraging decentralized storage.

## 04 Testnet Update

- [04 Testnet Update](https://docs.wal.app/blog/04_testnet_update.md):
    Today, a community of operators launches the first public Walrus Testnet. This is an important
    milestone in validating the operation of Walrus as a decentralized blob store, by operating it
    on a set of independent storage nodes, that change over time through a delegated proof of stake
    mechanism.

## 05 Testnet Redeployment

- [05 Testnet Redeployment](https://docs.wal.app/blog/05_testnet_redeployment.md):
    We are today redeploying the Walrus Testnet to incorporate various improvements, including some
    backwards-incompatible changes. Make sure to get the latest binary and configuration as
    described in the setup section. Note that all blob data on the previous Testnet instance has
    been wiped.

## 06 Mainnet

- [06 Mainnet](https://docs.wal.app/blog/06_mainnet.md):
    The production Walrus Mainnet is now live, and operated by a decentralized network of over 100
    storage nodes. Epoch 1 begun on March 25, 2025.

## Blob Operations Quickstart

- [Blob Operations Quickstart](https://docs.wal.app/docs/blob-operations-quickstart.md):
    This quickstart shows the core blob operations, store, read, and check status, three ways: the
    Walrus CLI, the HTTP API, and Python. Each operation appears in all three so you can pick the
    surface that fits your stack, or compare them side by side. Walrus does not ship a dedicated
    Python SDK.

## Console

- [API Reference](https://docs.wal.app/docs/console/api-reference.md):
    The Console developer API covers the endpoints third-party developers use to manage spaces,
    folders, and files, plus the Seal endpoints that back private-folder access control. > Info > >
    The Console developer API is in beta at . Endpoint shapes might change before GA.
- [Auth](https://docs.wal.app/docs/console/auth.md):
    Walrus Console signs you in with the Google or Apple account you already have. There is no
    wallet to connect, no seed phrase to record, and no crypto setup: you sign in and start storing
    data. > Info > > Walrus Console is available on Mainnet through a closed, invite-only beta.
- [FAQ](https://docs.wal.app/docs/console/faq.md):
    Common questions about Walrus Console. For the concepts behind the answers, read What is Walrus
    Console?, and for a hands-on walkthrough, follow the Quick Start. > Info > > Walrus Console is
    available on Mainnet through a closed, invite-only beta.
- [Mcp Server](https://docs.wal.app/docs/console/mcp-server.md):
    The Walrus Console MCP server gives an AI client the same file and folder operations you get in
    the web app. Your agent creates folders, uploads and downloads files, and checks storage usage,
    while encryption and signing stay on your machine. The package is , licensed MIT. Node.js 24 or
    later.
- [Overview](https://docs.wal.app/docs/console/overview.md):
    Walrus Console is the developer-first interface for interacting with the Walrus network. It
    gives you a hosted place to store, manage, and serve data without running your own Walrus
    client or handling wallets and tokens directly.
- [Quickstart](https://docs.wal.app/docs/console/quickstart.md):
    Go from sign-up to a working encrypted upload: create an account, mint an API key, then create
    a Seal-encrypted folder and upload, download, and decrypt a file. > Info > > The Console
    developer API is in beta at api.console.walrus.xyz. Endpoint shapes might change before GA.
- [Storage Epochs](https://docs.wal.app/docs/console/storage-epochs.md):
    Walrus storage is time-bound. Your data stays available for a set amount of storage, measured
    in epochs, and expires when that storage runs out. Walrus Console tracks and pays for this so
    you do not manage epochs by hand, and it extends storage automatically before it runs out.

## Large Uploads

- [Large Uploads](https://docs.wal.app/docs/large-uploads.md):
    The maximum blob size on Walrus is approximately 13.6 GB. Uploading large data sets or
    individual blobs larger than 1 GB require certain workarounds and planning for optimal
    performance and efficiency. After you plan your upload strategy, estimate the storage costs for
    your data.

## Network Reference

- [Network Reference](https://docs.wal.app/docs/network-reference.md):
    The volatile values you need to integrate with Walrus all live here: aggregator and publisher
    endpoints, upload relay endpoints, package IDs, system and staking object IDs, token units, and
    configuration snippets.

## Production Readiness

- [Production Readiness](https://docs.wal.app/docs/production-readiness.md):
    A prototype that stores a blob on Testnet is not yet ready for production. Moving to Mainnet
    adds real cost, real failure modes, and the need to keep an upload path available under load.

## Release Notes

- [Release Notes](https://docs.wal.app/docs/release-notes.md):
    Walrus — Release notes from Walrus. Walrus Memory — Release notes from Walrus Memory, including
    the MCP server, TypeScript SDK, Python SDK, and OpenClaw. Walrus Sites — Release notes from
    Walrus Sites.
- [Walrus Memory](https://docs.wal.app/docs/release-notes/walrus-memory.md):
    September 15, 2026 | GitHub Unrecognised options now warn on stderr and in the structured log
    (cli.unrecognisedarg) instead of being dropped in silence, so a typo'd --namesapce work no
    longer writes to the default namespace with nothing to say it had.
- [Walrus Platform](https://docs.wal.app/docs/release-notes/walrus-platform.md):
    Testnet | September 9, 2026 | GitHub --- Mainnet | September 2, 2026 | GitHub Adds a metric
    counting sync-and-recovery info publications that invalidate the node-recovery baseline and
    supersede in-flight node-recovery runs.
- [Walrus Sites](https://docs.wal.app/docs/release-notes/walrus-sites.md):
    July 10, 2026 | GitHub The portal gains a glob-based route/redirect matcher behind a flag
    (first step of the routing migration), and the site-builder migrates off JSON-RPC-only client
    methods ahead of the JSON-RPC deprecation.

## Sponsored Uploads

- [Sponsored Uploads](https://docs.wal.app/docs/sponsored-uploads.md):
    Most users do not hold SUI or WAL, and most apps do not want to ask them to. To build an app
    where your backend pays for Walrus storage and users upload without managing a wallet, you need
    to choose among several patterns.

## Testnet Reference

- [Testnet Reference](https://docs.wal.app/docs/testnet-reference.md):
    Walrus Testnet is a free, non-durable network for development and testing. Read values that
    change from the canonical Network Reference, which is the single maintained source.

## Walrus Memory: API

- [Memory Read API](https://docs.wal.app/walrus-memory/api/memory-read-api.md):
    Registered routes (colon form used by the docs freshness check): GET /v1/owners/:owner/agents
    Owner-scoped, cursor-based, read-only.
- [Owner Token Auth](https://docs.wal.app/walrus-memory/api/owner-token-auth.md):
    Issuance route: POST /v1/owner-tokens. Lets Console call WM's owner-scoped read API without
    ever holding a delegate key.
- [1. Request and sign the returned personal-message challenge in the wallet.](https://docs.wal.app/walrus-memory/api/security-delete.md):
    The Security Delete API permanently deletes legacy Walrus Blob objects that were tracked in
    Walrus Memory's old-V1 database. The server selects and verifies the objects, builds and
    sponsors the Sui transaction, and executes it.

## Walrus Memory: Guides

- [Agent Runtimes](https://docs.wal.app/walrus-memory/guides/agent-runtimes.md):
    Agents built on EVM, Base, Virtuals, or any other stack can use Walrus Memory. The runtime your
    agent executes in and the chain it transacts on are independent of where its memory lives.
    Walrus Memory stores memories as encrypted blobs on Walrus and records ownership in a Sui
    account.
- [Delete Memories Programmatically](https://docs.wal.app/walrus-memory/guides/delete-memories-programmatically.md):
    Use the Security Delete API to find memories owned by a wallet, select memories older than a
    cutoff date, and permanently delete them. The API prepares and sponsors the Sui transaction;
    your wallet authenticates the requests and signs the prepared transaction. > Warning > >
    Deletion is permanent.
- [Delete Old Memories](https://docs.wal.app/walrus-memory/guides/delete-old-memories.md):
    As part of ongoing security improvements, we're giving you the option to review and remove
    memories you no longer want stored on Walrus Memory. This guide shows you how to preview your
    memories and delete any you'd like to clear. > Warning > > Deleting a memory is permanent and
    you cannot undo it.
- [Manage Your Memory](https://docs.wal.app/walrus-memory/guides/manage-your-memory.md):
    Your Walrus Memory account accumulates memories over time. See what you have stored, organize
    it with namespaces, renew memories before they expire, and delete the ones you no longer want,
    from the dashboard or through the SDK. [x] A Sui wallet that owns the memories you want to
    manage.
- [Returning User](https://docs.wal.app/walrus-memory/guides/returning-user.md):
    Your memories live on Walrus and your account lives on Sui, so they persist no matter which
    device you sign in from. Only the delegate key your browser used last time stays behind.
- [System Prompt Templates](https://docs.wal.app/walrus-memory/guides/system-prompt-templates.md):
    Connecting the MCP server gives an agent the memory tools. It does not make the agent use them.
    Most agents write only when the user says "remember this", which is why an untuned setup
    produces a handful of memories and then goes quiet. A system prompt fixes that.

## Walrus Memory: Handover

- [Security Sweep Reconcile](https://docs.wal.app/walrus-memory/handover/security-sweep-reconcile.md):
    | Field | Value | |---|---| | Linear | COMG-726 | | Parent postmortem | WM Seal decryption
    authorization incident (AI-13) | | Related process ticket | COMG-722 (AI-9) (not completed
    here) | | Sweep sources | v1 → v1new migrator review (SEC #1, #42, #44, #47; dated 2026-08-11)
    · SEC2-102 children · GH #360/#368/#398/#443/#469/#500/#501 | | Code snapshot | origin/dev @
    (2026-08-31) | | Method | Repo grep + git ls-tree/git show on origin/dev.

## Walrus Memory: Migration

- [Ceremony Environments](https://docs.wal.app/walrus-memory/migration/ceremony-environments.md)

## Walrus Memory: Ops

- [Migration Completion Artifact](https://docs.wal.app/walrus-memory/ops/migration-completion-artifact.md):
    After a security migration, write a completion artifact that records the target package,
    reviewed manifest digest, imported counts, verification result, and approver. Keep the file
    with the operator record.
- [Security Rc Workflow](https://docs.wal.app/walrus-memory/ops/security-rc-workflow.md):
    Every release-candidate batch gets Security review capacity (human, AI, or combined) before it
    ships. Classify the change set, keep one candidate in one PR, and request Security review when
    the change requires it. One candidate release, or one security-sensitive change set, is one PR.

## Walrus Memory: Python SDK

- [API Reference](https://docs.wal.app/walrus-memory/python-sdk/api-reference.md):
    See also: Configuration Relayer API Source: python-sdk/api-reference.md MemWalSync.create(...)
    has the same signature and returns a synchronous wrapper.
- [Colab](https://docs.wal.app/walrus-memory/python-sdk/colab.md):
    Use the runnable Walrus Memory Python SDK Colab when you want a notebook-first walkthrough.
- [Quick Start](https://docs.wal.app/walrus-memory/python-sdk/quick-start.md):
    The Walrus Memory Python SDK (memwal on PyPI) gives your agents portable memory that works
    across apps, sessions, and workflows. Store, recall, and analyze context, fully under your
    control. It mirrors the TypeScript MemWal client: same relayer, same Ed25519 auth, same
    methods.
- [1. Fire and forget the wait — poll later if you need the blobid](https://docs.wal.app/walrus-memory/python-sdk/usage.md):
    The Python SDK exposes one relayer-backed client in two forms, plus middleware: | Entry point |
    Import | When to use | | --- | --- | --- | | MemWal | from memwal import MemWal | Recommended
    default, async-native; relayer handles embeddings, Seal, and storage | | MemWalSync | from
    memwal import MemWalSync | Same API surface, synchronous, scripts, notebooks, non-async apps |
    | withmemwallangchain / withmemwalopenai | from memwal import ...
- [Memwal Manual](https://docs.wal.app/walrus-memory/python-sdk/usage/memwal-manual.md):
    > Note > > Unlike the TypeScript SDK there is no separate MemWalManual class in Python. The
    Python SDK is relayer-backed for the standard remember / recall flow.
- [Memwal](https://docs.wal.app/walrus-memory/python-sdk/usage/memwal.md):
    The recommended default client. The relayer handles embeddings, Seal encryption, Walrus upload,
    and vector indexing. The SDK only signs requests and sends text.
- [With Memwal](https://docs.wal.app/walrus-memory/python-sdk/usage/with-memwal.md):
    withmemwallangchain and withmemwalopenai wrap an existing LLM client with automatic memory
    management. Before each call relevant memories are recalled and injected; after each call the
    user message is analyzed for new facts (fire-and-forget).

## Walrus Memory: SDK

- [Advanced Usage](https://docs.wal.app/walrus-memory/sdk/advanced-usage.md):
    you already have a vector or encrypted payload you want fact extraction with analyze you want
    memory inside an AI SDK pipeline Use: rememberManual when you already have encrypted payload
    plus vector recallManual when you already have a query vector Use analyze when you want the
    relayer to extract facts from longer text and store them as memories.
- [Agent Storage Loop](https://docs.wal.app/walrus-memory/sdk/agent-storage-loop.md):
    This guide walks an autonomous agent through the complete storage loop on Testnet: set up the
    client with no interactive steps, batch many small writes, encrypt agent state, confirm each
    write landed before depending on it, then recall.
- [Ai Integration](https://docs.wal.app/walrus-memory/sdk/ai-integration.md):
    Walrus Memory includes an AI SDK integration for applications that already use model
    middleware.
- [API Reference](https://docs.wal.app/walrus-memory/sdk/api-reference.md):
    See also: Configuration Relayer API Source: sdk/api-reference.md Config: | Property | Type |
    Required | Default | Notes | | --- | --- | --- | --- | --- | | key | string | Yes | | Ed25519
    delegate private key in hex | | accountId | string | Yes | | MemWalAccount object ID on Sui | |
    serverUrl | string | No | | Relayer URL | | namespace | string | No | "default" | Default
    namespace for memory isolation | For the full config surface, see Configuration.
- [Cloudflare Workers](https://docs.wal.app/walrus-memory/sdk/cloudflare-workers.md):
    Walrus Memory runs on the Cloudflare Workers runtime, but the edge environment differs from
    Node.js in a few ways that affect bundling and reliability. The configuration and patterns
    below make it work cleanly.
- [Codebase Memory](https://docs.wal.app/walrus-memory/sdk/codebase-memory.md):
    AI coding assistants like Cursor appear to remember a codebase because they retrieve relevant
    context at query time rather than holding an entire repository in the model's context window.
- [Cookbook Multi Tenant](https://docs.wal.app/walrus-memory/sdk/cookbook-multi-tenant.md):
    This is the pattern for SaaS-style apps where one operator runs a server that stores memory on
    behalf of many end users. For example, a Next.js app on Vercel where users connect a Sui wallet
    only for sign-in, and the server holds the credentials.
- [Examples](https://docs.wal.app/walrus-memory/sdk/examples.md):
    The shortest working Walrus Memory example using the default relayer-backed SDK.
- [Headless Setup](https://docs.wal.app/walrus-memory/sdk/headless-setup.md):
    A server or agent runtime has no human to click through a wallet or paste a key at a prompt.
    The Walrus Memory SDK initializes entirely from configuration, so you can drop it into a
    backend service, a cron job, or an autonomous agent.
- [Overview](https://docs.wal.app/walrus-memory/sdk/overview.md):
    Walrus Memory exposes SDK surfaces for TypeScript and Python. The SDKs give your agents
    portable memory that works across apps, sessions, and workflows, fully under your control. Use
    this first.
- [Production Readiness](https://docs.wal.app/walrus-memory/sdk/production-readiness.md):
    The SDK gives you the storage primitives. Running them in a long-lived agent, where there is no
    human to retry a failed write or notice a runaway bill, takes a few patterns on top. This guide
    collects the ones that matter most. Several of these are patterns you implement around the
    client today.
- [Quick Start](https://docs.wal.app/walrus-memory/sdk/quick-start.md):
    The Walrus Memory SDK gives your agents portable memory that works across apps, sessions, and
    workflows. Store, recall, and analyze context, fully under your control.
- [Usage](https://docs.wal.app/walrus-memory/sdk/usage.md)
- [Memwal Manual](https://docs.wal.app/walrus-memory/sdk/usage/memwal-manual.md):
    Use when the client must handle embedding calls and local Seal operations. The relayer still
    handles upload relay, vector registration, search, and restore. This is the recommended path
    for Web3-native users who want to minimize trust in the relayer, because it never sees your
    plaintext data.
- [Memwal](https://docs.wal.app/walrus-memory/sdk/usage/memwal.md):
    The recommended default client. The relayer handles embeddings, Seal encryption, Walrus upload,
    and vector indexing.
- [With Memwal](https://docs.wal.app/walrus-memory/sdk/usage/with-memwal.md):
    Drop-in memory middleware for Vercel AI SDK apps.
- [Versioned Datasets](https://docs.wal.app/walrus-memory/sdk/versioned-datasets.md):
    When an agent stores a dataset, a model artifact, or a snapshot of its own state, it usually
    needs more than the latest copy. It needs the history: which version it acted on, what changed
    between revisions, and proof that a past version has not been altered.

## Walrus Memory: Troubleshooting

- [Overview](https://docs.wal.app/walrus-memory/troubleshooting/overview.md):
    This page collects the support questions that come up most often and the fastest way to resolve
    each one. Every entry lists the symptom you observe, the cause behind it, and the fix to apply.

## Walrus Oyster API: JSON API

- [Access Keys](https://docs.wal.app/oyster/json-api/access-keys.md):
    S3 access keys let you authenticate with Oyster's S3-compatible API using standard AWS
    Signature Version 4. Each access key consists of an access key ID (20 characters, prefixed with
    OYAK) and a secret access key (40 hex characters). You can have up to 3 active access keys per
    account.
- [550e8400-e29b-41d4-a716-446655440000](https://docs.wal.app/oyster/json-api/admin.md):
    The Admin API lets app operators manage accounts, API keys, and S3 access keys. All admin
    endpoints require admin-key authentication (long-lived per-app Bearer tokens issued through
    oysterd app issue-admin-key; see Authentication). An app can only manage accounts it created.
- [Authentication](https://docs.wal.app/oyster/json-api/authentication.md):
    Oyster uses Bearer tokens for authenticated routes plus public access for blob reads and
    infrastructure probes. There are two tiers of Bearer token, distinguished by which routes they
    unlock; both share the same wire format.
- [Returns 304 if unchanged, 200 with body if changed](https://docs.wal.app/oyster/json-api/blobs.md):
    Blobs are binary objects stored inside buckets. Each blob is identified by a user-chosen key
    (like a file path) and has a content-addressed blob ID computed from its contents.
- [Buckets](https://docs.wal.app/oyster/json-api/buckets.md):
    Buckets are named containers that hold your blobs. Bucket names are globally unique: no two
    accounts can have a bucket with the same name.
- [HELP oysteractiveaccounts Number of active accounts](https://docs.wal.app/oyster/json-api/infrastructure.md):
    These endpoints are used for health monitoring and observability. They do not require
    authentication and are not under the /api/v1/ prefix. Always returns 200 OK. Use this as a
    Kubernetes liveness probe or a simple "is the server running?" check.
- [Wallet](https://docs.wal.app/oyster/json-api/wallet.md):
    Each Oyster account has an associated Sui wallet address, derived from the account's identity
    by the Pearl custodial wallet service. This wallet is used for onchain operations when blobs
    are stored on Walrus. Returns the Sui wallet address associated with your account.

## Walrus Oyster API: S3 API

- [Buckets](https://docs.wal.app/oyster/s3-api/buckets.md):
    All bucket operations require S3 authentication (SigV4). See S3 Setup for configuration.
    Creates a new bucket.
- [Limitations](https://docs.wal.app/oyster/s3-api/limitations.md):
    Oyster implements the most commonly used S3 operations. The sections below document what's
    different from a full AWS S3 deployment.
- [Create-only: fail if the key already exists](https://docs.wal.app/oyster/s3-api/objects.md):
    All S3 operations require authentication (SigV4), including reads. See S3 Setup for
    configuration. > Authenticated reads: Unlike the JSON API, where > blob reads are public and
    unauthenticated, all S3 reads require authentication. Uploads an object to a bucket.
- [Create a bucket](https://docs.wal.app/oyster/s3-api/setup.md):
    Configure the AWS CLI and SDKs to work with Oyster's S3-compatible API using the steps below.

## Optional

### Tusky Migration Guide

- [Tusky Migration Guide](https://docs.wal.app/docs/tusky-migration-guide.md):
    As of December 19, 2025, the storage service Tusky is shutting down. Data stored on Walrus
    through Tusky is still safe and accessible. During Tusky's sunsetting period, you can continue
    reading your data, however you must either migrate to using Walrus directly or through
    alternative tooling.

### Legal

- [Privacy](https://docs.wal.app/docs/legal/privacy.md):
    > Looking for the developer documentation? > > You are reading a legal document. To build on
    Walrus, start with Get started, Walrus Sites, or the Walrus Memory docs, where you can also
    open the Ask Walrus AI assistant for technical questions.
- [Testnet TOS](https://docs.wal.app/docs/legal/testnet_tos.md):
    > Looking for the developer documentation? > > You are reading a legal document. To build on
    Walrus, start with Get started, Walrus Sites, or the Walrus Memory docs, where you can also
    open the Ask Walrus AI assistant for technical questions.
- [Walrus General TOS](https://docs.wal.app/docs/legal/walrus_general_tos.md):
    > Looking for the developer documentation? > > You are reading a legal document. To build on
    Walrus, start with Get started, Walrus Sites, or the Walrus Memory docs, where you can also
    open the Ask Walrus AI assistant for technical questions.