Auto Drive was built to make permanent, on-chain storage as simple as any cloud storage tool you already use. Today, we are taking a meaningful step toward the broader vision: you can now pay for storage directly with AI3, the native token of the Autonomys Network.
What This Means
Until now, accessing Auto Drive credits required going through us. Foundation grants, manual credit allocations, and forms to fill out. That worked as a starting point, but it was never the end state. Pay with AI3 removes the intermediary entirely. If you hold AI3, you can purchase storage credits directly, on your own terms, without asking anyone for permission.
For developers, that shift has a practical benefit worth naming. You can now build applications on top of Auto Drive with a storage layer that is self-sufficient from day one, funded by the token, and free from any dependency on foundation access programs. That is a meaningful shift in what it means to build on Autonomys.
How It Works
The user-facing flow is straightforward. Sign in via Google, connect your EVM wallet, select how much storage you want to purchase, and complete the transaction. Your credits are available within a few blocks. From there, the experience is identical to what Auto Drive users already know: upload through the dashboard at ai3.storage, integrate via the Auto SDK, or call the REST API directly.
Storage pricing is derived from the on-chain cost of the Autonomys Distributed Storage Network, with a service fee applied on top. The price per byte is transparent and updated every block.
Under the Hood
For the developers in the room, here is what is actually happening when you click Purchase.
The contract. Pay with AI3 is mediated by a single Solidity contract — AutoDriveCreditsReceiver — deployed on the Autonomys Auto-EVM (chain ID 870) at 0xBa5bed8325183c0807EcBC80C82D40Dc7Ac5cbf7. It exposes one user-facing function:
function payIntent(bytes32 intentId) public payable whenNotPaused;
event IntentPaymentReceived(bytes32 indexed intentId, uint256 paymentAmount);
The intent. Before you sign anything, the backend mints a payment intent. An intent is a server-side record that locks a price and binds a bytes32 ID to your account for a short window. Its state machine is small and deliberate:
PENDING ──► CONFIRMED ──► COMPLETED
│ │
├──► EXPIRED │ (price-lock window passed without payment)
├──► FAILED │ (paid amount too small to grant any bytes)
└──► OVER_CAP◄ (payment confirmed, but per-user cap exceeded)
PENDING intents expire 10 minutes after creation if unpaid. The cost of on-chain storage or the shannonsPerByte price is captured at creation time and is immutable — your transaction settles against the price you saw, not the price at confirmation.
The pricing oracle. When you request a quote, the backend opens a Substrate connection to the Autonomys consensus chain and reads the live, protocol-level cost of storing one byte on the DSN. We add a service fee to cover Auto Drive indexing, gateway retrieval, and operations, and return the result via GET /intents/price. Because every intent issues a fresh RPC, your quote reflects the chain state of the block the intent was minted in.
The handshake. Once you submit the on-chain transaction, the frontend posts the resulting tx hash back to POST /intents/:id/watch. The backend’s payment manager runs a poller waits for 6 blocks to confirm the on-chain transaction.
Granting credits. Once the intent is CONFIRMED, a polling loop computes the amount of storage that needs to be credited to the user based on the transaction amount and cost-of-storage locked in the payment intent and grants it to the user.
Spending credits. Uploads consume purchased_credits rows in ORDER BY expires_at ASC, purchased_at ASC — so the credits closest to expiring are always spent first.
A Note on Current Limitations
We want to be upfront about the restrictions in place at launch. These are deliberate economic protections, not permanent product decisions. The Autonomys Network is still in its early growth phase, and we need to prevent storage credit hoarding or speculative accumulation that would work against how the system is designed to operate. The goal is for storage credits to be used, not held.
The protections currently in place are these:
-
Google authentication is required to purchase credits. The check runs at the REST layer (
POST /intents/returns403 GOOGLE_ACCOUNT_REQUIREDotherwise) and API keys inherit the OAuth provider of their owner — so server-side integrations work as long as the owning account signed in with Google. -
Each account can hold a maximum of 100 GB of purchased storage credits at any time. This is enforced atomically inside the credit-grant transaction; if a confirmed payment would push you past the cap, the intent moves to
OVER_CAPand is recoverable rather than lost. -
Purchased credits expire 90 days after grant. An hourly background job marks expired batches and any unused bytes are forfeited from the user’s balance. We are working on automated refunds for unused credits at expiry — for now, expiry forfeiture is logged per-batch and recoverable through support.
We want people storing data, not accumulating capacity they never intend to use.
These constraints will be revisited as the network matures and we have clearer data on real usage patterns. If you are building something that these limits add friction to, reach out. For full details on Pay with AI3 Terms of Use, please visit: autonomys.xyz/auto-drive-terms-of-use
Building on Top of Pay with AI3
If you are building an application that stores data on behalf of your users, the natural question is how payment works in that context. Pay with AI3 gives you options. Your application can handle storage costs directly — minting intents under your own API key and paying them from an application-controlled wallet — or you can have users purchase their own credits under their own Auto Drive identity and authorize your app to spend against them. The right approach depends on your use case, and we expect different patterns to emerge as the ecosystem matures.
The first application built against it is Eulonomys, a tool for creating permanent, on-chain eulogies. It is open source (GitHub) and designed to serve as a reference for one way third-party applications can integrate Auto Drive and Pay with AI3 end to end.
The developer experience matters to us as much as the end-user experience. As more applications come online, the integration surface will mature, and we will document the patterns that prove out in practice. If you are building something now and want guidance, reach out.
For Web2 Developers
If you are new to Web3 and do not yet hold AI3, that is not a barrier to getting started. We are still happy to provide a meaningful amount of complimentary credits so you can explore Auto Drive, test integrations, and build with confidence before committing to a purchase. Sign up at ai3.storage and the free tier is available immediately upon account creation.
Looking further ahead, we are actively exploring fiat payment options. The vision for Auto Drive has always been that anyone, regardless of their familiarity with crypto or token markets, should be able to access permanent decentralized storage on their own terms. Pay with AI3 is a major step in that direction. Fiat access would complete it, and we are thinking carefully about what that looks like. It is also worth noting that the contract surface is permissionless — nothing prevents a third party from building a fiat-to-payIntent bridge independently, and we think that is an interesting opportunity for the right builder.
Why This Matters
The Autonomys Network was built from the ground up to provide permanent, on-chain storage as a protocol-level guarantee. What was missing was a direct, permissionless path to access it through AI3. Pay with AI3 addresses that directly. It connects the economic layer of the Autonomys Network to the storage layer in a way that does not require trusting a foundation, waiting on a grant, or asking for access. The price is read from the chain. The payment is made to a contract. The credit grant is triggered by an event. That is the kind of infrastructure that developers building production applications can actually depend on, and it is what we have been working toward from the start.
Get started at: ai3.storage. Full SDK documentation is available at: develop.autonomys.xyz/sdk/auto-drive