Bringing Walrus to the IPFS Ecosystem Through Lighthouse
IPFS builders can now store data on Walrus Protocol directly from Lighthouse – verifiable, high-performance storage with no migration or rewrite.
Lighthouse is a developer platform for decentralized storage, trusted by 2,000+ startups and protocols including Aethir, SingularityNET, and Ocean Protocol. It now lets developers pin IPFS blobs to Walrus, the Verifiable Data Platform, directly from its default IPFS client – keeping their existing CIDs, gateways, and SDK.
In this article
Key takeaways
- Walrus is now reachable from inside the IPFS ecosystem, with 2,000+ Lighthouse builders able to store on Walrus through the workflows they already use.
- Walrus adds verifiability with onchain proofs anchored on Sui, plus parallel retrieval from multiple nodes for consistent reads
- Integration to support future agentic use cases for Lighthouse, from programmable access controls to agents paying for their own storage via x402.
Lighthouse is a developer platform for decentralized storage, built on IPFS. More than 2,000 startups and protocols build on it today across AI, DePIN, and Web3, including Aethir, SingularityNET, Ocean Protocol, and Nuklai.
As these businesses scaled, their needs evolved toward large files, frequent reads, and stronger availability guarantees. IPFS provides addressability, but not verifiable proof that data is stored and available. Walrus integration was the natural next step.
Walrus is now the storage backend behind Lighthouse. Builders keep their CID-based workflows, IPFS gateways, and existing SDK, allowing developers to store on Walrus through the same workflows they already use.
What Walrus brings to Lighthouse
Files uploaded through Lighthouse are pinned, made addressable by CID, and protected with client-side encryption and access controls. What customers increasingly wanted was a storage tier with performant retrieval, where availability is provable.
This is where Walrus comes in:
- Performance. Each blob is erasure-coded into pieces distributed across the network. Reads pull from multiple nodes in parallel, not whichever single node happens to be serving content at a given moment, meaning fast, consistent retrieval even under frequent access.
- Verifiability. Proofs are anchored on Sui, giving developers guarantees around storage and availability that are on-chain and checkable.
Verifiable storage, through infrastructure builders already use
Lighthouse preserves compatibility with existing workflows. CIDs and IPFS gateways work natively, with Walrus sitting underneath as the storage backend. Developers get the performance and verifiability of Walrus without changing how they build or migrating data by hand.
"Lighthouse is making it possible for thousands of IPFS builders to build on Walrus’ performance and verifiability without changing a thing about how they work," said Kostas Chalkias, Co-Founder and Chief Cryptographer at Mysten Labs, original contributors to Walrus. "Two powerful ecosystems coming together creates an enormous surface area for innovation in AI and decentralized applications."
Agent storage and beyond
The integration opens up new AI use cases on the Lighthouse roadmap. With native encryption and access controls, Walrus makes it possible for agents to independently create durable memory outside any centralized service. Paired with the upcoming x402 integration, storage will soon be payable in stablecoins, with no human in the loop.
"The IPFS ecosystem and Walrus are a perfect fit, and Lighthouse is where they come together," said Nandit Mehra, Co-Founder at Lighthouse. "Developers keep the CID workflow they already know, Walrus delivers the retrieval performance underneath, and the whole ecosystem compounds. Every new team that lands brings more AI, DePIN, and enterprise workloads with it."
Store on Walrus through Lighthouse
Phase one of the integration is now live. If you're building a dapp on Solana or Ethereum and using IPFS today, you can store data on Walrus while keeping every one of your existing CID-based workflows. Faster retrieval, onchain availability proofs, and agent-native storage – without changing how you build.
FAQs
What does storing on Walrus add to data that's on IPFS?
IPFS makes data addressable by CID and keeps it available as persistent storage. Walrus adds a layer where availability is provable – erasure-coded blobs for ~800ms retrieval on sub-1MB files, 2/3 fault tolerance, and storage proofs anchored on Sui – without changing the CID workflows developers already use.
Do developers have to migrate their data or rewrite their code to use Walrus through Lighthouse?
No. CIDs and IPFS gateways work natively, files stay connected to the IPFS network, and the existing Lighthouse SDK is unchanged. Walrus sits underneath as the storage backend, and migration tooling is available for teams that want to move existing data across.
Can other decentralized-storage platforms use Walrus the same way?
Yes. The Lighthouse integration shows Walrus can act as a drop-in verifiable backend beneath an existing CID-based storage layer. Any platform serving read-heavy, availability-critical workloads can adopt Walrus underneath without disrupting how its developers build.
About Walrus
Walrus is a Verifiable Data Platform for builders in AI and onchain finance. No more fragile foundations: Walrus finally makes it possible to verify where data came from, prove it hasn't been tampered with, and know it's always available, without compromising on speed. It is the foundation for applications where unverifiable data can cause irrecoverable losses. The more we trust AI and onchain finance with our money and decisions, the more mission-critical this becomes. Created by the ex-Meta engineers behind Sui.
About Lighthouse
Lighthouse is a developer platform for decentralized storage, built on IPFS. We give teams a single SDK, CLI, and dashboard to store, encrypt, and retrieve files without running their own infrastructure or stitching together pinning services. Over 2,000 startups and protocols are built on Lighthouse today, including Aethir, SingularityNET, Ocean Protocol, and Nuklai, across AI, DePIN, and Web3.
