x402 Payments on Monad with Solvador

Accept x402 payments on Monad with Solvador

If you want to accept x402 payments on Monad, you need a facilitator to verify and settle them. Solvador is that facilitator.

You point your x402 middleware at Solvador, keep pricing in plain USD, and we handle verification and on chain settlement on Monad. The same integration also covers every other network we support, so you write it once and reuse it everywhere.

Every x402 scheme, supported on Monad

Solvador implements all three x402 settlement schemes on Monad, so you can match the scheme to your product instead of forcing your product to fit one payment shape:

• exact. Charge a precise, fixed amount per request. Ideal for flat priced endpoints, one off unlocks, and simple pay per call APIs.
• upto. Pre authorize a maximum and settle only what was actually consumed, up to that cap. This is the natural fit for metered and usage based billing, where you do not know the final amount until the work is done. On EVM networks the upto authorization runs through Permit2.
• batch-settlement. Aggregate many verified payments into far fewer on chain settlements. This is what makes high volume micropayments and agent to agent traffic economical, because you stop paying settlement overhead on every individual call.

One facilitator, one integration, all three schemes. You are never locked into a single billing model.

One integration, every network

The real cost of going multichain is not the payment, it is the infrastructure behind it. Solvador collapses that:

• Integrate once and cover Monad plus 14 other networks through the same facilitator.
• No per network facilitator to run, monitor, or maintain.
• Adding Monad to an app that already uses Solvador is a config value, not a rewrite.
• Identical developer experience across every supported network, so your team learns it once.

You price in USD, your users pay in stablecoins, and Solvador settles on Monad.

From zero to first payment in under 3 minutes

Frictionless onboarding is the point. Here is the whole path from nothing to a live 402 payment on Monad.

1. Grab your Solvador API key.

Create a key in your Solvador dashboard and keep it in an environment variable. You will pass it to the facilitator on every verify and settle call.

export SOLVADOR_API_KEY="your_api_key"

2. Add the x402 middleware to your server.

npm install @x402/express @x402/core @x402/evm

3. Point it at Solvador and pick Monad.

import express from "express";
import { paymentMiddleware, x402ResourceServer } from "@x402/express";
import { HTTPFacilitatorClient } from "@x402/core/server";
import { ExactEvmScheme } from "@x402/evm/exact/server";

const app = express();

const facilitator = new HTTPFacilitatorClient({
  url: "https://api.solvador.com",
  createAuthHeaders: async () => {
    const auth = { "X-API-Key": process.env.SOLVADOR_API_KEY };
    return { verify: auth, settle: auth, supported: {} }; // /supported is public
  },
});

app.use(
  paymentMiddleware(
    {
      "GET /api/premium": {
        accepts: [
          {
            scheme: "exact",
            price: "$0.05",
            network: "eip155:143", // Monad
            payTo: "0xYourReceivingAddress",
          },
        ],
      },
    },
    new x402ResourceServer(facilitator)
      .register("eip155:143", new ExactEvmScheme())
  )
);

app.get("/api/premium", (req, res) => {
  res.json({ data: "paid content on Monad" });
});

app.listen(3000);

4. Make a paid request from any x402 client.

import { wrapFetchWithPayment } from "@x402/fetch";
import { x402Client } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm/exact/client";

const client = new x402Client();
client.register("eip155:*", new ExactEvmScheme(walletClient));

const fetchWithPay = wrapFetchWithPayment(fetch, client);
const res = await fetchWithPay("http://localhost:3000/api/premium");

That is it. Your endpoint now returns 402 Payment Required, the client pays in stablecoins, Solvador verifies and settles on Monad, and your content is served. No per network glue code, no facilitator to operate.

Why Monad

Monad is a high performance EVM Layer 1 built for parallel execution, high throughput, and low latency. Cheap, fast blocks make it especially well suited to high volume micropayments and batch settlement heavy workloads.

Whatever brought you to Monad, Solvador makes it a payment ready network from day one, with the exact same developer experience you get everywhere else we support.

FAQ

Which x402 schemes does Solvador support on Monad? All three: exact, upto, and batch-settlement. On EVM networks the upto scheme uses Permit2 for the authorization.

How long does integration take? Most developers go from install to their first live payment in under 3 minutes. It is a middleware install plus one config value.

What tokens can I accept on Monad? Any ERC-20. Any token that implements EIP-3009, such as USDC, EURC, or AUSD, gets the smoothest path with no on chain approval step. Every other ERC-20 is handled through Permit2, where the one time Permit2 approval can be sponsored via EIP-2612 or done once manually. Confirm the current asset list for Monad in the Solvador docs before launch.

Can I use the same code on other networks? Yes. Switching networks is a config change. The same Solvador integration covers every supported network.

Start building on Monad

Ship your first x402 payment on Monad today. Read the docs and grab your facilitator endpoint at solvador.com.