Funding still depends on a human.
An agent's wallet runs out. A human has to top it up. Then it runs out again. The autonomy stops the moment the balance hits zero, and somebody has to be there to refill it.
Private, yield-funded autopay for agents
Deposit once. Earn yield. Pay for agent API calls without revealing who you paid.
Press through the flow. With official x402, each call settles as a direct USDC transfer from the buyer's wallet to the seller, so anyone reading the chain can see exactly which buyer paid which seller. Subly-x402 keeps the same HTTP flow, but hides the link between buyer and seller on-chain by routing settlement through the Private Shared Vault.
The live proof below calls the same Seller twice. One call goes through official x402, the other through Subly-x402. The API response is identical. What changes is the visible on-chain trail and whether any observer can tell who paid whom.
Both paths start with a normal HTTP request and a 402 challenge. The privacy difference starts with where the payment is allowed to settle.
When the proof runs, the buyer pays the seller directly. That direct transfer is what becomes visible onchain.
The seller's 402 challenge points the buyer at a seller payTo account.
Waiting for direct payment
Nothing until settlement
Payment not broadcast yet
The first highlighted step is the buyer depositing into the Vault. Seller settlement is handled separately by Subly-x402 batching.
The seller's 402 challenge points the buyer at an attested Subly vault policy.
Waiting for vault deposit
Vault deposit not made yet
Batch settlement has not been queued yet
Press Run live demo to fill the flow above with real Solana devnet transactions. Below you can verify the Vault, Signer, and Policy this demo is using, plus the confirmed direct/deposit tx hashes once the run completes.
This hosted proof targets an approximately 1 minute Subly-x402 batch. The LP stops at the Buyer-to-Vault deposit because the later seller settlement is a Vault batch, not a per-demo completion signal. Public deployments should use longer anonymity windows. Low-volume 1 minute batches can make participant correlation easier.
A real devnet run returns both Seller route calls, funding txs, the x402 settlement tx, the Subly vault deposit tx, and the Subly settlement id.
Paste a Solana devnet wallet address. The server creates the associated USDC token account if needed and sends 100.000000 USDC.
Subly-x402 ships as two open-source packages. A Buyer SDK and Express middleware for Sellers. Drop them into any TypeScript project. There is no API key, no gatekeeper.
npm install and you're an x402 buyer or seller.$ npm install subly402-sdk subly402-expressapp.use(x402PaymentMiddleware({
"GET /x402/weather": {
accepts: [{
scheme: "exact",
network: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
payTo: process.env.SELLER_WALLET!,
price: {
asset: process.env.SUBLY402_USDC_MINT!,
amount: "1100000",
},
}],
},
}, officialX402ResourceServer));const sublyResourceServer = new Subly402ResourceServer(facilitator)
.register("solana:devnet", new Subly402ExactScheme());
app.use(sublyPaymentMiddleware({
"GET /subly/weather": {
accepts: [{
scheme: "exact",
price: 1100000,
network: "solana:devnet",
sellerWallet: process.env.SELLER_WALLET!,
}],
},
}, sublyResourceServer));const x402Client = new X402Client()
.register(
"solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
new X402ExactSvmScheme(buyer, { rpcUrl })
);
const x402Fetch = wrapX402FetchWithPayment(fetch, x402Client);
await x402Fetch("http://seller.demo.sublyfi.com/x402/weather");const client = new Subly402Client({
trustedFacilitators: ["https://api.demo.sublyfi.com"],
autoDeposit: {
maxDepositPerRequest: "1100000",
deposit: async ({ amountAtomic, details }) => {
await depositIntoSublyVault({ amountAtomic, details });
},
},
policy: { maxPaymentPerRequest: "1100000" },
}).register("solana:*", new Subly402ExactScheme(buyer));
const sublyFetch = wrapSublyFetchWithPayment(fetch, client);
await sublyFetch("http://seller.demo.sublyfi.com/subly/weather");x402 lets agents pay providers over HTTP. It still leaves two gaps. Durable funding and payment privacy.
An agent's wallet runs out. A human has to top it up. Then it runs out again. The autonomy stops the moment the balance hits zero, and somebody has to be there to refill it.
Every x402 payment settles as a direct transfer from Buyer to Seller on-chain. Anyone can see what an agent bought, who it paid, and when. That is not privacy-preserving payment infrastructure.
Turn yield into agent payments without exposing who your agent paid.
An agent deposits USDC into Subly once. The vault earns DeFi yield that pays for x402 calls while the principal remains withdrawable. Settlement flows through an on-chain shared vault, and a TEE keeps per-buyer accounting private while scheduling payouts. The direct Buyer-to-Seller link that x402 normally exposes disappears.
The agent transfers USDC into the Subly vault once. Principal stays in your custody and can be withdrawn at any time.
Deposited capital earns yield in DeFi, with a 5-10% APY target. Yield, not principal, funds your agent's calls.
Buyers and sellers still use x402-style HTTP. Payments flow into the on-chain shared vault first. The TEE keeps the per-buyer ledger off-chain and triggers delayed vault payouts, so the direct on-chain link disappears.
The agent makes one USDC transfer into the shared Subly vault. After that, payments can keep running without manual top-ups.
The vault routes capital into DeFi with a 5-10% APY target. Principal stays put, and yield funds the agent's calls.
Buyers call providers through x402-style HTTP. A TEE keeps per-buyer accounting private and schedules batched vault payouts, so observers cannot link Buyer to Seller.
Subly's on-chain programs, including the Shared Vault, are encrypted by Arcium. The per-buyer ledger lives inside a TEE. Once Solana's Confidential SPL transfers reach mainnet, Subly plans to integrate them so vault transfer amounts can also stay private.
Subly's on-chain programs, including the Shared Vault that holds user funds, are encrypted by Arcium. The on-chain data stays encrypted end to end, and computation runs directly over the ciphertext without ever decrypting it.
The per-buyer accounting that tracks who spent what is kept off-chain inside a TEE instead of on Solana. The ledger can still be opened to a regulator or auditor on the buyer's terms.
Solana's upcoming Confidential SPL transfers will keep transfer amounts hidden on-chain. Once they ship to mainnet, Subly plans to integrate them so the amounts moving through the Shared Vault can also be kept private.
Agents are becoming one of the fastest-growing consumers of paid APIs.
Subly starts with API Payments via AI Agents: the per-call API payments an agent makes through x402-style HTTP 402. From there, it can grow into the broader agent economy.
Join early access for AI agent builders.