Solana Pay: How to Accept Crypto Payments on Solana (2026)

Every time a customer pays with a credit card, the merchant loses 2.5–3.5% to payment processors. On a $100 purchase, that's $3.50 gone. For a business doing $500K/year in sales, credit card fees eat $12,500–$17,500 annually. That money goes to Visa, Mastercard, Stripe, and the issuing banks — not to the merchant, not to the customer.

Solana Pay eliminates nearly all of that. A USDC payment on Solana costs less than $0.01 in transaction fees, settles in under 400 milliseconds, and hits the merchant's wallet with no intermediary taking a cut. No chargebacks, no 2-day settlement windows, no merchant account applications.

This isn't theoretical. Merchants from coffee shops to e-commerce stores are using Solana Pay in production today. This guide covers everything you need to know — whether you're a merchant looking to reduce fees or a developer building payment integrations.

How Solana Pay Works

Solana Pay is an open-source payment protocol, not a company. It's a specification for encoding payment requests into URLs and QR codes that any Solana wallet can read. There's no signup, no approval process, no monthly fees. It's a standard that anyone can implement.

The protocol supports two modes:

Transfer Requests (Simple Payments)

The basic mode. A Transfer Request encodes a recipient wallet address, an amount, and an SPL token (usually USDC) into a URL. When scanned, the customer's wallet app constructs and signs the transfer transaction directly.

The URL format is straightforward:

solana:MERCHANT_WALLET?amount=25.00&spl-token=USDC_MINT&reference=UNIQUE_REF&label=StoreName&message=Order%20%23123

That's it. No API calls, no server-side processing. The customer's wallet reads the URL, shows the payment details, and sends the tokens directly to the merchant's wallet. The reference parameter is a randomly generated public key added to the transaction, which the merchant's system monitors to confirm payment.

Transaction Requests (Programmable Payments)

The advanced mode. Instead of encoding the full payment in the URL, a Transaction Request points to a server endpoint that dynamically generates the transaction. This enables:

Dynamic pricing (convert USD to SOL at current rates)
Loyalty points (mint NFTs or tokens as rewards in the same transaction)
Conditional logic (apply discounts, check inventory)
Multi-instruction transactions (payment + receipt NFT + loyalty token in one atomic transaction)
Token swaps (customer pays in any token, merchant receives USDC via Jupiter aggregation)

When the customer scans the QR code, their wallet fetches the transaction from your server, displays it for approval, signs it, and submits it to the network. The merchant's server monitors for confirmation.

Why Merchants Should Care

The fee comparison alone makes the case:

Payment Method	Fee per $100 Transaction	Settlement Time	Chargebacks
Visa/Mastercard	$2.50–$3.50	1–3 business days	Yes
Stripe	$2.90 + $0.30	2 business days	Yes
PayPal	$3.49 + $0.49	Instant to PayPal balance	Yes
Square	$2.60 + $0.10	1–2 business days	Yes
Solana Pay (USDC)	~$0.005	~400ms	No

That's not a marginal improvement — it's an order-of-magnitude reduction in payment processing costs. For high-volume merchants, the savings are substantial.

No Chargebacks

This is underrated. Credit card chargebacks cost U.S. merchants over $40 billion annually. A customer can dispute a charge months after purchase, and the merchant bears the burden of proof. Chargeback fraud (friendly fraud) accounts for roughly 60–75% of all chargebacks.

Blockchain transactions are final. Once a USDC transfer confirms on Solana, it's irreversible. The merchant receives the funds, period. For businesses selling digital goods, services, or operating in high-chargeback industries, this alone justifies the switch.

Instant Settlement

Credit card settlements take 1–3 business days. That's cash you've earned sitting in limbo. On Solana, USDC arrives in your wallet within seconds. Better cash flow, better treasury management, no waiting.

Global by Default

No merchant account applications. No country restrictions (from the protocol side). A merchant in Lagos accepts USDC from a customer in Tokyo the same way they'd accept it from someone across the street. Same fees, same speed, same finality.

Shopify Integration

The most practical way for e-commerce merchants to adopt Solana Pay is through Shopify. Multiple apps bridge Solana Pay into the Shopify checkout flow.

Using Helio Pay / Sphere

Sphere provides a Shopify plugin that adds Solana Pay as a checkout option. Setup takes about 15 minutes:

Install the Sphere Shopify app from the Shopify App Store
Connect your Solana wallet (any wallet — Phantom is the most common)
Configure accepted tokens (USDC, SOL, or both)
Enable the payment method in your Shopify checkout settings

Customers see "Pay with Solana" at checkout alongside traditional payment options. They scan a QR code or connect their wallet (on mobile, deep links open the wallet app directly). Payment confirms in seconds, and the order is automatically marked as paid in Shopify.

Sphere also handles:

Automatic currency conversion: Price items in USD, accept USDC
Webhook notifications: Real-time payment confirmation to your backend
Multi-token acceptance: Let customers pay in SOL, BONK, or other SPL tokens while you receive USDC
Refund management: Issue refunds through the dashboard

Using Solana Pay Directly

If you want more control or are building a custom Shopify storefront, you can integrate the Solana Pay JavaScript SDK directly:

import { createQR, encodeURL, findReference, validateTransfer } from '@solana/pay';
import { Connection, PublicKey, Keypair } from '@solana/web3.js';

// Create a payment request
const recipient = new PublicKey('YOUR_MERCHANT_WALLET');
const amount = new BigNumber(25.00);
const reference = Keypair.generate().publicKey;
const label = 'Your Store';
const message = 'Order #1234';

const url = encodeURL({
  recipient,
  amount,
  splToken: USDC_MINT,
  reference,
  label,
  message,
});

// Generate QR code
const qr = createQR(url, 360, 'transparent');
qr.append(document.getElementById('qr-container'));

// Poll for payment confirmation
const connection = new Connection('YOUR_RPC_ENDPOINT');
const signatureInfo = await findReference(connection, reference, { finality: 'confirmed' });
await validateTransfer(connection, signatureInfo.signature, {
  recipient,
  amount,
  splToken: USDC_MINT,
});

// Payment confirmed — fulfill the order

The findReference function polls the blockchain for a transaction containing the reference key. Once found, validateTransfer verifies the correct amount was sent to the correct recipient. The whole flow takes 5–10 seconds from scan to confirmed payment.

Point-of-Sale for Physical Stores

For brick-and-mortar merchants, the flow is similar but optimized for in-person transactions.

The Basic Setup

All you need is a tablet or phone displaying a QR code. The simplest approach:

Generate a static QR code for your wallet address (works for fixed-price items)
Or use a simple web app that generates dynamic QR codes per transaction

Dedicated POS Solutions

Several projects have built dedicated point-of-sale interfaces for Solana Pay:

Sphere Terminal: A web-based POS terminal. Enter the amount, generate a QR code, customer scans and pays. Transaction history and daily totals built in.
TipLink: TipLink takes a different approach — instead of QR codes, you create payment links that work on any device. Useful for invoicing and remote payments, but also works in-person. The key advantage: customers don't need a wallet app. TipLink creates a temporary custodial wallet, so even crypto newcomers can pay using just a link and a credit card to fund it.

Handling Price Volatility

If you accept USDC, there's no volatility concern — 1 USDC = $1 (within the typical stablecoin peg range). This is why most merchants default to USDC acceptance.

If you accept SOL directly, you'll want to either:

Instant conversion: Use a Transaction Request that swaps SOL to USDC via Jupiter in the same transaction
Off-ramp regularly: Convert SOL to fiat through an exchange on a daily/weekly schedule
Hold: If you're bullish on SOL and can absorb the volatility

Most merchants go with option 1 or simply accept USDC only.

Developer Guide: Building Payment Integrations

Payment Links (No Backend Required)

The simplest integration. Generate a Solana Pay URL and encode it as a QR code. No server needed.

import { encodeURL } from '@solana/pay';
import BigNumber from 'bignumber.js';
import { PublicKey } from '@solana/web3.js';

const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');

function createPaymentLink(merchantWallet, amountUsd, orderId) {
  const reference = Keypair.generate().publicKey;

  const url = encodeURL({
    recipient: new PublicKey(merchantWallet),
    amount: new BigNumber(amountUsd),
    splToken: USDC_MINT,
    reference,
    label: 'My Store',
    message: `Order #${orderId}`,
    memo: orderId, // On-chain memo for reconciliation
  });

  return { url, reference };
}

The reference is crucial — it's how you track whether a specific payment has been made. Store it alongside the order in your database, then poll for it:

async function waitForPayment(connection, reference) {
  let signatureInfo;

  while (!signatureInfo) {
    try {
      signatureInfo = await findReference(connection, reference, {
        finality: 'confirmed',
      });
    } catch (e) {
      // Not found yet, keep polling
      await new Promise(resolve => setTimeout(resolve, 500));
    }
  }

  return signatureInfo;
}

Transaction Requests (Full Control)

For dynamic pricing, loyalty rewards, or multi-step flows, use Transaction Requests. Your server generates the transaction:

// Server endpoint: POST /api/pay
export async function POST(req) {
  const { account } = await req.json(); // Customer's wallet address

  const transaction = new Transaction();

  // 1. Transfer USDC from customer to merchant
  transaction.add(
    createTransferCheckedInstruction(
      customerTokenAccount,
      USDC_MINT,
      merchantTokenAccount,
      new PublicKey(account),
      25_000_000, // 25 USDC (6 decimals)
      6
    )
  );

  // 2. Mint a receipt NFT (optional)
  transaction.add(
    createMintReceiptInstruction(account, orderId)
  );

  // 3. Add loyalty points (optional)
  transaction.add(
    createLoyaltyRewardInstruction(account, points)
  );

  transaction.feePayer = new PublicKey(account);
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;

  // Return serialized transaction
  return Response.json({
    transaction: transaction.serialize({ requireAllSignatures: false }).toString('base64'),
    message: 'Payment for Order #1234',
  });
}

The customer's wallet fetches this transaction, displays the details, and the customer signs it. One click, one signature, multiple on-chain actions.

Monitoring Payments at Scale

For high-volume merchants, polling findReference for every pending order doesn't scale. Better approaches:

WebSocket subscriptions: Subscribe to your merchant wallet's token account for transfer notifications
Helius webhooks: Set up webhooks that fire on incoming USDC transfers to your wallet
Transaction log indexing: Use Helius or a custom indexer to process all transactions referencing your program

Solana Pay vs. Traditional Crypto Payment Processors

How does Solana Pay compare to services like BitPay or Coinbase Commerce?

Feature	Solana Pay	BitPay	Coinbase Commerce	Stripe Crypto
Transaction fee	~$0.005	1%	1%	1.5%
Settlement	Instant	1–2 days	1–2 days	2 days
Tokens	Any SPL token	BTC, ETH, stables	BTC, ETH, stables	USDC only
Fiat conversion	Manual / via exchanges	Built-in	Built-in	Built-in
Chargebacks	None	None	None	None
KYC required	No (protocol level)	Yes (merchant)	Yes (merchant)	Yes
Open source	Yes	No	No	No
Self-custodial	Yes	No	No	No

The trade-off is clear: Solana Pay is cheaper and faster but requires more self-service. BitPay and Coinbase Commerce handle fiat conversion, tax reporting, and compliance. Solana Pay gives you raw crypto-to-crypto transfers — you handle the rest.

For merchants who are comfortable managing crypto or who want to keep funds in USDC/SOL, Solana Pay is the obvious choice. For merchants who need automatic fiat conversion and compliance tooling, a managed service like Sphere or a traditional crypto processor might be better — though Sphere operates on Solana Pay under the hood.

Real Merchant Use Cases

E-Commerce

Online stores selling digital goods (courses, software, templates) are the lowest-friction adopters. No physical shipping, instant delivery, and the chargeback elimination alone is worth the switch. A creator selling a $50 digital course keeps $49.995 via Solana Pay versus ~$48.20 via Stripe.

Freelancers and Agencies

International payments are where crypto shines. A freelancer in Argentina billing a client in Germany doesn't need SWIFT transfers (3–5 days, $25–$50 fees). A USDC transfer via Solana settles in seconds for less than a penny. TipLink is particularly useful here — send a payment link, the recipient claims funds even without a pre-existing wallet.

Physical Retail

Coffee shops and restaurants experimenting with crypto payments typically start with a simple tablet displaying a QR code at checkout. The key insight: don't force it. Offer it as an option alongside card payments. Crypto-native customers will use it; others won't. The setup cost is essentially zero.

Subscription Services

Transaction Requests enable recurring payment flows. The customer approves a payment schedule, and your system generates transactions on the billing cycle. Combined with Solana's account delegation features, you can build subscription models that don't require the customer to manually approve each payment.

Setting Up Off-Ramps

If you need to convert USDC to fiat, your options include:

Direct exchange withdrawal: Send USDC to Coinbase, Kraken, or Binance and sell for fiat. Fees vary (0.1–0.5% on the exchange, plus withdrawal fees to your bank).
OTC desks: For large volumes ($50K+), OTC desks offer better rates than exchange order books.
On-ramp services: Services like MoonPay and Transak offer merchant APIs for automatic USDC-to-fiat conversion.

The most cost-effective path for most merchants: accumulate USDC, convert weekly on a major exchange. Even with exchange fees, you're still paying less than credit card processing.

Security Considerations

A few things to get right:

Always validate transfers server-side. Never trust the client to confirm payment. Use validateTransfer or check on-chain state directly. A customer could modify the QR code or submit a transaction for $0.01 instead of $100.
Use unique references per transaction. The reference key must be unique for each order. Reusing references means you can't distinguish between payments.
Secure your merchant wallet. Use a dedicated wallet for receiving payments, separate from your personal wallet. Consider a multisig setup (via Squads) for large-volume operations.
Monitor for token account creation. If a customer pays you in a token you don't have an account for, the transaction will fail. Ensure your merchant wallet has token accounts for all accepted SPL tokens.

Getting Started Today

The fastest path to accepting Solana payments:

Create a dedicated merchant wallet using Phantom or any Solana wallet
For e-commerce: Install Sphere's Shopify plugin or integrate the Solana Pay SDK into your checkout
For in-person: Use Sphere's terminal or generate QR codes from a simple web app
For invoicing: Create payment links via TipLink
Set up payment monitoring: Use Helius webhooks or poll with findReference
Configure off-ramps: Set up an exchange account for USDC-to-fiat conversion when needed

The Solana Pay protocol is mature, well-documented, and battle-tested. The ecosystem tools around it — Sphere, TipLink, and wallet apps like Phantom — have made the integration path smooth enough that any merchant or developer can be accepting payments within an afternoon.

The real question isn't whether Solana Pay works. It does. The question is whether your customers have Solana wallets — and with Phantom alone surpassing 20 million active users, that customer base is growing fast.