Monetization

How partners earn revenue from Velora swaps: partner fees, surplus sharing, and how the revenue split differs between Delta and Market.

Velora gives partners two revenue levers on every swap they route: a partner fee (a fixed cut in basis points) or a surplus share (half of any positive slippage the routing engine or solver network captures). The two are mutually exclusive on a single swap, and the split between partner, user, and Velora differs between Delta and Market.

How partners earn

• Partner fee. A fixed basis-point cut subtracted from the swap output. Predictable per-trade revenue, but it worsens the user-facing quote because the fee comes off the top.
• Surplus share. When the route or solver overdelivers vs. the quoted output, that positive slippage is the surplus. Partners can claim 50% of it, leaving the user-facing quote untouched. Revenue is variable; it depends on routing edge.

A swap can carry one lever or the other, not both. If a request sets both, the partner fee takes precedence and the surplus flag is ignored.

Requests without a partner identifier fall back to the anon partner, which charges a flat 1 bps fee. To unlock the levers above, attach your own partner identifier. See Pro API accounts.

Revenue splits at a glance

How each lever splits revenue between the partner and Velora:

Lever	Delta	Market
Partner fee*	100% partner	85% partner / 15% Velora
Surplus share	50% partner / 50% Velora	50% partner / 50% Velora

Delta returns 100% of the partner fee to the partner because the protocol funds itself from surplus on the Delta side, not from per-swap fees. On Market, Velora takes a 15% cut of the partner fee to fund routing infrastructure.

The partner’s half of the surplus can be redirected to the end user instead by setting isSurplusToUser: true. And if neither lever is active, any surplus the route captures stays with Velora.

_{* Tailored arrangements available on request.}

How it maps to the API

Delta (GET /v2/quote) and Market (GET /prices, POST /transactions) accept the same monetization parameters per request. isDirectFeeTransfer is Market-only.

Parameter	Type	Default	Purpose
partner	string	anon	Identifies your integration; ties the request to your partner economics
partnerAddress	address	—	On-chain recipient of fees or surplus share
partnerFeeBps	string (bps)	—	Fixed fee in basis points. "200" = 2%. Max enforced by your partner tier
takeSurplus	boolean	false	Opt into surplus collection. Requires partner or partnerAddress
isSurplusToUser	boolean	false	Route surplus to the end user. Requires takeSurplus: true
isDirectFeeTransferMarket	boolean	false	Bypass the Fee Claimer contract and transfer fees to partnerAddress per swap

partnerFeeBps and takeSurplus are mutually exclusive: set one or the other. The legacy positiveSlippageToUser flag is deprecated; use isSurplusToUser instead.

Pass partnerFeeBps to the quote endpoint (GET /prices or GET /v2/quote) so the fee is reflected in the displayed quote.

Fee delivery

On Market, partner fees accrue inside the Fee Claimer contract by default. Partners claim accumulated balances through the Velora Fee Claimer UI, signed by partnerAddress. This batches gas across many swaps but adds a claim step. To skip the Fee Claimer and pay fees directly to partnerAddress on every swap, set isDirectFeeTransfer: true. There’s nothing to claim, but each swap carries an extra fee-transfer, and the user pays that gas on every trade, including very low-value ones where it can eat a meaningful share of the output.

On Delta, fees accrue inside the main Delta contract and partners claim them directly from there; there is no separate Fee Claimer contract. This works in Delta’s favor: the fee is accounted for as part of the fill itself, with no extra fee-transfer per swap, so taking a partner fee adds essentially no gas overhead to the trade.

Surplus routed to the user (isSurplusToUser: true) is settled in the same transaction as the swap, so there’s no claim step either way.

How to claim

Fee Claimer UI

Accumulated Market fees are claimable from the Fee Claimer app. Connect the wallet matching partnerAddress, pick the chain, review the available balances per token, and submit a claim transaction. Each chain is claimed separately; gas is paid by the claimer.

The UI covers Market fees only. Delta fees are claimed programmatically from the Delta contract, as shown below.

Programmatically

Both fee contracts can be called directly, so claims can run from a script or a scheduled job instead of the UI. In either case, sign the transaction with the wallet matching partnerAddress: balances are keyed to it, and each call sweeps the full accrued balance of one token to a recipient you choose. Delta fees accrue in the Delta contract and are withdrawn with withdrawAllFees; Market fees accrue in the Fee Claimer contract and are withdrawn with withdrawAllERC20. Each contract uses the same address on every chain where it’s deployed (see Chains & contracts), so the same code works on another chain by swapping the viem chain object.

Claim Delta fees

import { createPublicClient, createWalletClient, http, parseAbi } from "viem";
import { Address, privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";

// Delta address on Ethereum mainnet
const DELTA_ADDRESS = "0x0000000000bbf5c5fd284e657f01bd000933c96d";

const feeClaimerModuleAbi = parseAbi([
  "function getCollectedFees(address partner, address token) view returns (uint256)",
  "function withdrawAllFees(address token, address recipient) returns (uint256 amount)",
]);

const account = privateKeyToAccount(process.env.PRIVATE_KEY);

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
});

const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
});

async function withdrawAllFees(
  tokenAddress: Address,
  recipientAddress: Address
) {
  const collectedFees = await publicClient.readContract({
    address: DELTA_ADDRESS,
    abi: feeClaimerModuleAbi,
    functionName: "getCollectedFees",
    args: [account.address, tokenAddress],
  });

  console.log(
    `Collected fees for token ${tokenAddress}:`,
    collectedFees.toString()
  );

  if (collectedFees === 0n) {
    console.log("No fees to withdraw for this token.");
    return;
  }

  // Simulate first to catch reverts
  const { request } = await publicClient.simulateContract({
    account,
    address: DELTA_ADDRESS,
    abi: feeClaimerModuleAbi,
    functionName: "withdrawAllFees",
    args: [tokenAddress, recipientAddress],
  });

  const hash = await walletClient.writeContract(request);
  console.log("Transaction sent:", hash);

  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  console.log("Withdrawal confirmed in block:", receipt.blockNumber);

  return receipt;
}

// Withdraw all accrued USDC fees to the caller's address
await withdrawAllFees(
  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  account.address
);

Next steps

Pro API accounts

Free partner IDs, plus paid tiers for higher rate limits and SLA.

Widget monetization

Drop-in partnerConfig for the React widget.

Delta overview

Gasless intents, solver competition, and surplus economics.

Delta API overview

GET /v2/quote and intent submission reference.

Market API overview

GET /prices and POST /transactions reference.

Endpoints work without a partner identifier, but fees and surplus only activate once one is attached; picking your own partner value costs nothing. When you outgrow the free tier, Pro API accounts layer on higher limits, a dashboard, and SLA, or reach out for custom terms.