Zoneless: open-source Stripe Connect replacement on Solana

Stripe Connect works. It's also expensive in a way that compounds at scale: $2 per active seller per month, 0.25% + $0.25 per domestic payout, $1.50 per international transfer, 0.25–1.25% cross-border fee, 0.5–1% FX on non-USD currencies. A marketplace running 1,000 monthly payouts averaging $30 with half going international is spending roughly $38,000 a year on payment infrastructure.

Zoneless replaces Stripe Connect with USDC payouts on Solana. The cost is approximately $0.002 per payout in SOL gas. Settlement is instant. The API is deliberately Stripe-compatible — same object shapes, same webhook event names, same idempotency key pattern. It's self-hosted, Apache 2.0, and was built by Ben Stokes, the founder of PromptBase.

Zoneless won the Solana Frontier Hackathon Public Good Award.

The cost comparison

These are real numbers from Zoneless's docs against Stripe Connect's published pricing:

                          Zoneless        Stripe Connect
Monthly account fee       Free            $2 / active account
Domestic payout fee       ~$0.002         0.25% + $0.25
International payout      ~$0.002         $1.50
Cross-border fee          None            0.25–1.25%
FX / currency conversion  None (USDC)     0.50–1%
Settlement speed          Seconds         2–7 business days
Geographic reach          220+ countries  Restricted by region

PromptBase — 450,000+ users — ran Zoneless alongside Stripe Connect for 14 weeks: 1,100+ payouts completed, 1,700+ sellers onboarded, and 72% of sellers chose Zoneless over Stripe when given the option. Their previous Stripe Connect spend was $9,400/month.

How it works

Zoneless has three moving parts: a self-hosted backend (Express.js), an Express-style seller dashboard (Angular), and a Node.js SDK. You run the backend, sellers connect their Solana wallets through the dashboard, and you call the API to trigger payouts.

The flow:

1. Seller opens your onboarding link → connects a Solana wallet (≈30 seconds)
2. Your platform receives a webhook: account.updated
3. You create a transfer via the SDK when a payout is due
4. Zoneless sends USDC from your platform wallet to the seller wallet on Solana
5. Seller receives funds instantly; converts to local currency via any exchange

Your platform wallet holds the USDC. Zoneless never touches it — it executes the transfer instruction on your behalf using credentials you control. There is no intermediary custody.

Installation

npm install zoneless
# or
yarn add zoneless

Initialising the client

import Zoneless from "zoneless";

const zoneless = new Zoneless({
  apiKey: process.env.ZONELESS_API_KEY!,
  // Points to your self-hosted Zoneless backend
  baseUrl: process.env.ZONELESS_BASE_URL!,
});

Creating a connected account (seller onboarding)

The object shape mirrors Stripe Connect's accounts.create:

const account = await zoneless.accounts.create({
  type: "express",
  email: "[email protected]",
  metadata: {
    user_id: "usr_1234",
  },
});

// Generate an onboarding link — send this to the seller
const link = await zoneless.accountLinks.create({
  account: account.id,
  refresh_url: "https://yourapp.com/onboarding/retry",
  return_url: "https://yourapp.com/onboarding/complete",
  type: "account_onboarding",
});

// redirect seller to link.url

Paying a seller (transfer + payout)

// Move funds from your platform balance to a connected account
const transfer = await zoneless.transfers.create({
  amount: 2500,          // in cents — $25.00
  currency: "usd",
  destination: account.id,
  transfer_group: "ORDER_95",
});

// Trigger the on-chain USDC transfer to the seller's wallet
const payout = await zoneless.payouts.create(
  {
    amount: 2500,
    currency: "usd",
    metadata: { order_id: "ORDER_95" },
  },
  {
    stripeAccount: account.id,   // same header pattern as Stripe
  }
);

console.log(payout.status); // "paid" — Solana confirms in ~400ms

Webhooks

Zoneless fires webhooks with identical event names to Stripe. If you already handle Stripe Connect webhooks, you can reuse the same handler:

// Express webhook handler — same structure as Stripe's
app.post("/webhooks/zoneless", express.raw({ type: "application/json" }), (req, res) => {
  const event = zoneless.webhooks.constructEvent(
    req.body,
    req.headers["zoneless-signature"] as string,
    process.env.ZONELESS_WEBHOOK_SECRET!
  );

  switch (event.type) {
    case "payout.paid":
      // Seller received USDC — mark payout complete in your DB
      const payout = event.data.object;
      console.log("Payout complete:", payout.id, "amount:", payout.amount);
      break;

    case "account.updated":
      // Seller finished onboarding — they're ready to receive payouts
      const account = event.data.object;
      console.log("Seller onboarded:", account.id);
      break;

    case "transfer.created":
      // Funds moved to connected account balance
      break;
  }

  res.json({ received: true });
});

Idempotency

Zoneless supports idempotency keys the same way Stripe does — pass idempotencyKey in the request options:

const payout = await zoneless.payouts.create(
  { amount: 2500, currency: "usd" },
  {
    stripeAccount: account.id,
    idempotencyKey: `payout-${orderId}`,
  }
);

Migrating from Stripe Connect

Because Zoneless intentionally mirrors Stripe's API surface, the migration surface is small. The main differences:

• SDK import — swap import Stripe from "stripe" for import Zoneless from "zoneless" and update the constructor.
• Currency — payouts settle in USDC on Solana. Sellers receive USDC to their wallet; fiat conversion is on them (Coinbase, Kraken, local exchange).
• Wallet onboarding — sellers connect a Solana wallet instead of a bank account. The onboarding link UX is the same flow.
• Self-hosted backend — you run the Zoneless server. There's no managed SaaS tier yet (in progress).

- import Stripe from "stripe";
- const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
+ import Zoneless from "zoneless";
+ const zoneless = new Zoneless({
+   apiKey: process.env.ZONELESS_API_KEY!,
+   baseUrl: process.env.ZONELESS_BASE_URL!,
+ });

- const transfer = await stripe.transfers.create({ ... });
+ const transfer = await zoneless.transfers.create({ ... });

- const payout = await stripe.payouts.create({ ... }, { stripeAccount: id });
+ const payout = await zoneless.payouts.create({ ... }, { stripeAccount: id });

Self-hosting

The zonelessdev/zoneless repo contains the full stack: the API server, the seller dashboard, and Docker configuration. At a minimum you need:

• A Solana wallet funded with USDC (your platform balance)
• A Postgres database for Zoneless's internal state
• A Node.js server to run the backend

git clone https://github.com/zonelessdev/zoneless
cd zoneless
cp .env.example .env
# Set SOLANA_RPC_URL, PLATFORM_WALLET_PRIVATE_KEY, DATABASE_URL, etc.
docker compose up -d

KYC/AML is not bundled — Zoneless handles payment routing only. You wire in your existing KYC provider (or skip it if your use case doesn't require it) the same way you would with any payments infrastructure.

Who it's for

Zoneless makes sense when:

• Your marketplace has a significant international seller base — where Stripe's $1.50/payout international fee hits hardest
• You're in a high-volume / low-average-payout category (digital goods, templates, microtasks) where Stripe's 0.25% + $0.25 floor dominates
• You want to pay sellers in markets Stripe doesn't support — Zoneless reaches 220+ countries via Solana
• Your sellers are already crypto-native and prefer wallet-based payouts

It's not the right tool if your sellers strongly prefer bank account payouts with no crypto interaction — the USDC-to-fiat conversion step adds friction that some demographics won't accept. PromptBase's 72% adoption rate suggests many sellers are fine with it; 28% still chose Stripe.